Programmation en langage C - Exercices corrigés sur les chaînes de caractères

Ce laboratoire propose une série d'exercices corrigés en langage C portant sur la manipulation des chaînes de caractères. Il permet d'apprendre à vérifier si une chaîne est un palindrome, compter des caractères spécifiques, inverser une chaîne, supprimer des caractères, et remplacer des sous-chaînes dans une chaîne principale. Pour réaliser ces exercices, il est nécessaire de disposer d'un compilateur C et d'un environnement permettant la saisie et l'affichage de texte.

Objectifs

• Vérifier si une chaîne de caractères est un palindrome.
• Compter le nombre d'occurrences d'un caractère donné dans une chaîne.
• Afficher une chaîne à l'envers, avec ou sans modification de la chaîne originale.
• Supprimer toutes les occurrences d'un caractère dans une chaîne.
• Remplacer une sous-chaîne par une autre de même taille dans une chaîne.
• Remplacer une sous-chaîne par une autre de taille différente dans une chaîne.

Prérequis et configuration

• Connaissances de base en langage C, notamment la gestion des chaînes de caractères.
• Utilisation des bibliothèques standard stdio.h et string.h.
• Un compilateur C compatible (ex : gcc).
• Un terminal ou un environnement pour saisir des chaînes et afficher les résultats.

Exercice 1 : Vérification d'un palindrome

Ce programme vérifie si une chaîne saisie est un palindrome, c'est-à-dire qu'elle se lit de la même façon de gauche à droite et de droite à gauche.

Le programme utilise un pointeur fin positionné à la fin de la chaîne, et compare les caractères aux extrémités en avançant vers le centre.

Un résultat correct affiche "palindrome" si la chaîne est symétrique, sinon "non palindrome".

#include<stdio.h>
#include<string.h>

int palindrome (char *ch)
{
    int pal=1;
    char *fin;
    fin=ch+strlen(ch)-1;
    printf("%c \n", *fin);
    for( ; ch<fin && (pal==1); ch++, fin--)
        if ( *ch != *fin ) pal=0;

    return pal;
}

void main()
{
    char ch[30];
    int res;
    puts("saisir une chaine");
    gets(ch);
    res= palindrome(ch);
    if (res==1) printf("palindrome");
    else printf (" non palindrome");
}

Exercice 2 : Analyse et inversion d'une chaîne

Ce programme lit une chaîne de moins de 200 caractères, puis :

• Affiche la longueur de la chaîne.
• Compte le nombre de caractères 'e' dans la chaîne.
• Affiche la chaîne à l'envers sans modifier la variable originale.
• Inverse la chaîne dans la variable, puis l'affiche.

La fonction nombre_e utilise strchr pour trouver chaque 'e'.

La fonction afficher_rebours affiche la chaîne en partant de la fin vers le début.

La fonction inverser échange les caractères aux extrémités pour inverser la chaîne en place.

Un résultat correct affiche la longueur, le nombre de 'e', puis la chaîne inversée deux fois (la deuxième fois modifiant la variable).

#include<stdio.h>
#include<string.h>

int nombre_e(char *ch)
{
    char *p;
    int nb_e=0;
    do
    {
        p=strchr(ch,'e');
        if(p!=NULL)
        {
            nb_e++;
            ch=p+1;
        }
    }
    while(p!=NULL);
    return nb_e;
}

void afficher_rebours (char *ch)
{
    char *p;
    for (p=ch+strlen (ch)-1; p>=ch; p--)
        printf("%c", *p);
}

void inverser(char *ch)
{
    char *debut, *fin;
    char aux;
    for(debut=ch, fin=ch+strlen(ch)-1 ; debut<fin ; debut ++, fin--)
    {
        aux=*debut;
        *debut=*fin;
        *fin=aux;
    }
}

void main()
{
    char ch[30];
    int l, nb_e;

    puts("saisir une chaine");
    gets(ch);

    l=strlen(ch);
    printf("la taille de la chaine est %d    \n",l);
    nb_e= nombre_e(ch);
    printf("le nombre de e est %d   \n", nb_e);

    printf("\n affichage a rebours sans changement \n");
    afficher_rebours (ch);

    printf("\n affichage a rebours apres changement \n");
    inverser (ch);

    puts(ch);
}

Exercice 3 : Suppression d'un caractère dans une chaîne

Ce programme lit une chaîne puis un caractère, et supprime toutes les occurrences de ce caractère dans la chaîne, en modifiant la variable originale.

La fonction supprimer utilise strchr pour localiser chaque occurrence, puis strcpy pour décaler la chaîne afin d'écraser le caractère supprimé.

Un résultat correct affiche la chaîne sans le caractère supprimé.

#include<stdio.h>
#include<string.h>

void saisir_caractere (char * k)
{
    printf("saisir un caractère   ");
    scanf("%c", k);
}

void supprimer (char *ch, char k)
{
    char *p;
    do
    {
        p=strchr(ch,k);
        if(p) strcpy(p, p+1);
    }
    while (p);
}

void main()
{
    char ch[50], k;
    printf("\n saisir une chaine  ");
    gets(ch);
    saisir_caractere(&k);
    supprimer (ch,k);
    puts (ch);
}

Exercice 4 : Remplacement d'une sous-chaîne par une autre de même taille

Ce programme lit une chaîne, puis deux mots de même taille, et remplace toutes les occurrences du premier mot par le second dans la chaîne originale.

La fonction modifier utilise strstr pour trouver les occurrences, puis strncpy pour remplacer sans modifier la taille de la chaîne.

Un résultat correct affiche la chaîne avec les remplacements effectués.

#include<stdio.h>
#include<string.h>

void modifier (char *ch, char *mot1, char *mot2)
{
    char *p;
    do
    {
        p=strstr(ch,mot1);
        if(p) strncpy(p, mot2, strlen(mot1));
    }
    while (p);
}

void main()
{
    char ch[50], mot1[20], mot2[20];
    printf("\n saisir une chaine  ");
    gets(ch);
    printf("\n saisir mot1  ");
    gets(mot1);
    printf("\n saisir mot2 de meme taille ");
    gets(mot2);
    modifier (ch,mot1, mot2);
    puts (ch);
}

Exercice 5 : Remplacement d'une sous-chaîne par une autre de taille différente

Ce programme lit une chaîne, puis deux mots (le second pouvant être de taille différente du premier), et remplace toutes les occurrences du premier mot par le second dans la chaîne originale.

La fonction modifier utilise strstr pour localiser les occurrences, puis copie temporairement la partie de la chaîne après le mot à remplacer dans un buffer, remplace le mot, et recolle la fin de la chaîne après le mot remplacé.

Un résultat correct affiche la chaîne avec les remplacements, même si la taille change.

#include<stdio.h>
#include<string.h>

void modifier (char *ch, char *mot1, char *mot2)
{
    char aide[20];
    char *p;

    do
    {
        p=strstr(ch,mot1);
        if(p)
        {
            strcpy(aide, p+strlen(mot1));
            strncpy(p, mot2, strlen(mot2));
            strcpy(p+strlen(mot2), aide);
        }
    }
    while (p);
}

void main()
{
    char ch[50], mot1[20], mot2[20];
    printf("\n saisir une chaine  ");
    gets(ch);
    printf("\n saisir mot1  ");
    gets(mot1);
    printf("\n saisir mot2 de taille différente     ");
    gets(mot2);
    modifier (ch,mot1, mot2);
    puts (ch);
}

Résultats attendus

• Exercice 1 : Affichage "palindrome" si la chaîne est symétrique, sinon "non palindrome".
• Exercice 2 : Affichage de la longueur de la chaîne, du nombre de 'e', puis la chaîne inversée deux fois (la deuxième modifiant la variable).
• Exercice 3 : Affichage de la chaîne sans le caractère supprimé.
• Exercice 4 : Affichage de la chaîne avec toutes les occurrences du premier mot remplacées par le second (même taille).
• Exercice 5 : Affichage de la chaîne avec toutes les occurrences du premier mot remplacées par le second (taille différente).

Pièges courants

• Utiliser gets est dangereux car il ne protège pas contre les débordements de tampon. Préférer fgets dans un contexte réel.
• Dans l'exercice 1, ne pas oublier que la chaîne doit être bien terminée et que les espaces ou majuscules peuvent fausser la détection du palindrome.
• Dans l'exercice 2, la fonction nombre_e modifie le pointeur de la chaîne, il faut donc ne pas utiliser la chaîne modifiée après sans la réinitialiser.
• Dans l'exercice 3, la suppression modifie la chaîne en place, il faut donc bien vérifier que la chaîne finale est correctement terminée.
• Dans les exercices 4 et 5, la fonction modifier peut entrer dans une boucle infinie si mot2 contient mot1 (en particulier dans l'exercice 5 où la taille peut changer).
• La taille des buffers (ch, mot1, mot2) doit être suffisante pour contenir les chaînes saisies et les modifications.