Exercices langage C : les chaines de caractères

Exercice 1

Ecrire un programme qui lit deux chaînes de caractères, et qui indique leur précédence lexicographique dans le code de caractères de la machine (ici: code ASCII). Testez votre programme à l'aide des exemples du chapitre 8.5.

 

Exercice 2

Ecrire un programme qui lit une chaîne de caractères CH et qui convertit toutes les majuscules dans des minuscules et vice-versa.

Le résultat sera mémorisé dans la même variable CH et affiché après la conversion.

 

Exercice 3

Ecrire une procédure qui lit une chaîne de caractères et l'interprète comme un entier positif dans la base décimale. Pour la conversion, utiliser les fonctions de <ctype> et la précédence alphabétique des caractères de '0' à '9'. Mémoriser le résultat dans une variable du type long. La conversion s'arrête à la rencontre du premier caractère qui ne représente pas de chiffre décimal. Utiliser un indicateur logique OK qui précise si la chaîne représente correctement une valeur entière et positive.

 

Exercice 4

Ecrire une procédure qui lit une chaîne de caractères et l'interprète comme un entier positif dans la base hexadécimale. Pour la conversion, utiliser les fonctions de <ctype> et la précédence alphabétique des caractères. La conversion ignore les caractères qui ne représentent pas de chiffre hexadécimal et s'arrête à la fin de la chaîne de caractères. Le résultat sera mémorisé dans une variable du type long et affiché dans les bases hexadécimale et décimale.

 

 Exercice 5

En se basant sur l'exercice 8.17, écrire un programme qui lit une chaîne de caractères et l'interprète comme un nombre rationnel positif ou négatif introduit en notation décimale. Mémoriser le résultat dans une variable du type double. Si le nombre a été introduit correctement, la valeur du résultat sera affichée, sinon le programme affichera un message d'erreur.

Méthode:

Utiliser une variable SIG pour mémoriser le signe de la valeur. Convertir tous les caractères numériques (avant et derrière le point décimal) en une valeur entière N. Compter les décimales (c.-à-d.: les positions derrière le point décimal) à l'aide d'une variable DEC et calculer la valeur rationnelle comme suit:

 

N = N * SIG / pow(10, DEC)

 

Exemples:

-1234.234 -1234.23400
-123 45 Erreur!
123.23. Erreur!
+00123.0123 123.012300

 

Exercice 6

En se basant sur l'exercice 8.19, écrire un programme qui lit une chaîne de caractères et l'interprète comme un nombre rationnel positif ou négatif introduit en notation exponentielle. Mémoriser le résultat dans une variable du type double. Si le nombre a été introduit correctement, la valeur du résultat sera affichée, sinon le programme affichera un message d'erreur.

Méthode:

Utiliser une variable SIGE pour mémoriser le signe de l'exposant. Utiliser une variable EXP pour la valeur de l'exposant. Calculer la valeur de l'exposant à l'aide de SIGE, DEC et EXP. Calculer ensuite la valeur exacte de N à l'aide d'une formule analogue à celle de l'exercice ci-dessus.

 

Exemples:

-1234.234 -1234.234000
-1234. 234 Erreur!
123E+02 123400.000000
123E-02 1.230000
123.4e 123.400000
-12.1234e02 -1212.340000
123.4e3.4 Erreur!
12.12E1 121.200000
12.12 E1 Erreur!

 

Exercice 7

Ecrire un programme qui supprime la première occurrence d'une chaîne de caractères OBJ dans une chaîne de caractères SUJ.

Exemples:

PHON ALPHONSE ALSE
EI PIERRE PIERRE
T TOTALEMENT OTALEMENT
HELLO HELLO

 

Exercice 8

Ecrire un programme qui remplace la première occurrence d'une chaîne de caractères CH1 par la chaîne CH2 dans une chaîne de caractères SUJ. Utiliser une chaîne de sauvegarde FIN pendant le remplacement.

Exemples:

PHON OY ALPHONSE ALOYSE
IE EI PIERRE PEIRRE
IE ARTE PIERRE PARTERRE
EI IE PIERRE PIERRE
TOT FIN TOTALEMENT FINALEMENT
TTT HELLO HELLO

 

Exercice 9

Ecrire un programme qui remplace toutes les occurrences d'une chaîne de caractères CH1 par la chaîne CH2 dans une chaîne de caractères SUJ. Utiliser une chaîne de sauvegarde FIN pendant le remplacement.

Exemples:

PHON OY ALPHONSE ALOYSE
AN ONT BANANE BONTONTE
T Y TOTALEMENT YOYALEMENY
TTT HELLO HELLO
L HELLO HEO

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <stdio.h>
main()
{
 /* Déclarations */
 char CH1[50], CH2[50]; /* chaînes à comparer */
 int I;                 /* indice courant     */

 /* Saisie des données */
 printf("Entrez la première chaîne à comparer : ");
 gets(CH1);
 printf("Entrez la deuxième chaîne à comparer : ");
 gets(CH2);

 /* Chercher la première position où */
 /* CH1 et CH2 se distinguent. */
 for (I=0; (CH1[I]==CH2[I]) && CH1[I] && CH2[I]; I++)
     ;
 /* Comparer le premier élément qui */
 /* distingue CH1 et CH2. */
 if (CH1[I]==CH2[I])
     printf("\"%s\" est égal à \"%s\"\n", CH1, CH2);
 else if (CH1[I]<CH2[I])
     printf("\"%s\" précède \"%s\"\n", CH1, CH2);
 else
     printf("\"%s\" précède \"%s\"\n", CH2, CH1);
  return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
main()
{
 /* Déclarations */
 char CH[100]; /* chaîne à convertir */
 int I;        /* indice courant     */

 /* Saisie de la chaîne */
 printf("Entrez la chaîne à convertir : ");
 gets(CH);
 /* Conversion de la chaîne */
 for (I=0; CH[I]; I++)
    {
     if (CH[I]>='A' && CH[I]<='Z')
                 CH[I] = CH[I]-'A'+'a';
     else if (CH[I]>='a' && CH[I]<='z')
                 CH[I] = CH[I]-'a'+'A';
    }
  /* Affichage de la chaîne convertie */
 printf("Chaîne convertie : %s\n", CH);
 return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <stdio.h>
#include <ctype.h>
 main()
{
 /* Déclarations */
 char CH[100]; /* chaîne numérique à convertir */
 long N; /* résultat numérique */
 int I;  /* indice courant */
 int OK; /* indicateur logique précisant si la */
         /* chaîne a été convertie avec succès */

 /* Saisie de la chaîne */
 printf("Entrez un nombre entier et positif : ");
 gets(CH);
 /* Conversion de la chaîne */
 OK=1;
 N=0;
 for (I=0; OK && CH[I]; I++)
     if (isdigit(CH[I]))
        N = N*10 + (CH[I]-'0');
     else
        OK=0;

 /* Affichage de la chaîne convertie */
 if (OK)
     printf("Valeur numérique : %ld\n", N);
 else
     printf("\a\"%s\" ne représente pas correctement "
           "un entier et positif.\n", CH);
 return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include <stdio.h>
#include <ctype.h>
 main()
{
 /* Déclarations */
 char CH[100]; /* chaîne numérique à convertir */
 long N; /* résultat numérique */
 int I;  /* indice courant */
 int OK; /* indicateur logique précisant si la */
         /* chaîne a été convertie avec succès */

 /* Saisie de la chaîne */
 printf("Entrez un nombre hexadécimal entier et positif : ");
 gets(CH);
 /* Conversion de la chaîne */
 OK=1;
 N=0;
 for (I=0; OK && CH[I]; I++)
     if (isxdigit(CH[I]))
       {
        CH[I] = toupper(CH[I]);
        if (isdigit(CH[I]))
           N = N*16 + (CH[I]-'0');
        else
           N = N*16 + 10 + (CH[I]-'A');
       }
     else
        OK=0;

 /* Affichage de la chaîne convertie */
 if (OK)
   {
    printf("Valeur numérique hexadécimale : %lX\n", N);
    printf("Valeur numérique décimale     : %ld\n", N);
   }
 else
    printf("\a\"%s\" n'est pas une valeur "
           "hexadécimale correcte.\n", CH);
 return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#include <stdio.h>
#include <math.h>
#include <ctype.h>
main()
{
 /* Déclarations */
 char CH[100]; /* chaîne numérique à convertir */
 double N; /* résultat numérique               */
 int I;    /* indice courant                   */
 int SIG;  /* signe de la valeur rationnelle   */
 int DEC;  /* nombre de décimales              */
 int OK;   /* indicateur logique précisant si la */
           /* chaîne a été convertie avec succès */

 /* Saisie de la chaîne */
 printf("Entrez un nombre rationnel : ");
 gets(CH);

 /* Conversion de la chaîne :    */
 /* Initialisation des variables */
  OK=1;
 N=0.0;
 I=0;
 SIG=1;
 /* Traitement du signe */
  if (CH[I]=='-') SIG=-1;
 if (CH[I]=='-' || CH[I]=='+') 
     I++;
 /* Positions devant le point décimal */
  for ( ; isdigit(CH[I]); I++)
     N = N*10.0 + (CH[I]-'0');
 /* Traitement du point décimal */
  if (CH[I]=='.')
     I++;
 else if (CH[I])
     OK=0;

 /* Traitement et comptage des décimales */
  for (DEC=0; isdigit(CH[I]); I++, DEC++)
     N = N*10.0 + (CH[I]-'0');
 if (CH[I]) OK=0;
 /* Calcul de la valeur à partir du signe et */
 /* du nombre de décimales. */
  N = SIG*N/pow(10,DEC);
 /* Affichage de la chaîne convertie */
 if (OK)
    printf("Valeur numérique : %f\n", N);
 else
    printf("\a\"%s\" n'est pas une valeur "
           "rationnelle correcte.\n", CH);
 return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#include <stdio.h>
#include <math.h>
#include <ctype.h>
main()
{/* Déclarations */
 char CH[100]; /* chaîne numérique à convertir */
 double N; /* résultat numérique */
 int I;    /* indice courant */
 int SIG;  /* signe de la valeur rationnelle */
 int DEC;  /* nombre de décimales  */
 int SIGE; /* signe de l'exposant  */
 int EXP;  /* valeur de l'exposant */
 int OK;   /* indicateur logique précisant si la */
           /* chaîne a été convertie avec succès */

 /* Saisie de la chaîne */
 printf("Entrez un nombre rationnel : ");
 gets(CH);

 /* Conversion de la chaîne */
 /* Initialisation des variables */
  OK=1;
 N=0.0;
 I=0;
 SIG=1;
 SIGE=1;
 /* Traitement du signe */
  if (CH[I]=='-') SIG=-1;
 if (CH[I]=='-' || CH[I]=='+') I++;
 /* Positions devant le point décimal */
  for ( ; isdigit(CH[I]); I++)
     N = N*10.0 + (CH[I]-'0');
 /* Traitement du point décimal */
  if (CH[I]=='.')
     I++;
 /* Traitement et comptage des décimales */
  for (DEC=0; isdigit(CH[I]); I++, DEC++)
     N = N*10.0 + (CH[I]-'0');
 /* Traitement de la marque exponentielle */
  if (CH[I]=='e'||CH[I]=='E')
     I++;
 else if (CH[I])
     OK=0;
 /* Traitement du signe de l'exposant */
  if (CH[I]=='-') SIGE=-1;
 if (CH[I]=='-' || CH[I]=='+') I++;
 /* Traitement de la valeur de l'exposant */
  for (EXP=0; isdigit(CH[I]); I++)
     EXP = EXP*10 + (CH[I]-'0');
 if (CH[I]) OK=0;
 /* Calcul de l'exposant à partir du signe  */
 /* SIGE, de la valeur de l'exposant EXP et */
 /* du nombre de positions rationnelles DEC */
  EXP = SIGE*EXP - DEC;
 /* Calcul de la valeur à partir du signe et */
 /* de l'exposant. */
  N = SIG*N*pow(10,EXP);

 /* Affichage de la chaîne convertie */
 if (OK)
    printf("Valeur numérique : %f\n", N);
 else
    printf("\a\"%s\" n'est pas une valeur "
           "rationnelle correcte.\n", CH);
 return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#include <stdio.h>
main()
{
 /* Déclarations */
 char SUJ[100]; /* chaîne à transformer        */
 char OBJ[100]; /* chaîne à supprimer dans SUJ */
 int I;         /* indice courant dans SUJ     */
 int J;         /* indice courant dans OBJ     */
 int TROUVE;    /* indicateur logique qui précise */
                /* si la chaîne OBJ a été trouvée */

 /* Saisie des données */
 printf("Introduisez la chaîne à supprimer   : ");
 gets(OBJ);
 printf("Introduisez la chaîne à transformer : ");
 gets(SUJ);
 /* Recherche de OBJ dans SUJ */
 TROUVE=0;
 for (I=0; SUJ[I] && !TROUVE; I++)
    /* Si la première lettre est identique, */
    if (SUJ[I]==OBJ[0])
        {
         /* alors comparer le reste de la chaîne */
         for (J=1; OBJ[J] && (OBJ[J]==SUJ[I+J]); J++)
            ;
         if (OBJ[J]=='\0') TROUVE=1;
        }
 /* Si la position de départ de OBJ dans SUJ a été trouvée */
 /* alors déplacer le reste de SUJ à cette position. */
 if (TROUVE)
    {
     I--;
     /* Maintenant  I indique la position de OBJ */
     /* dans SUJ et J indique la longueur de OBJ */
     for (; SUJ[I+J]; I++)
          SUJ[I]=SUJ[I+J];
     SUJ[I]='\0';
    }
  /* Affichage du résultat */
 printf("Chaîne résultat : \"%s\"\n", SUJ);
 return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#include <stdio.h>
main()
{
 /* Déclarations */
 char SUJ[100]; /* chaîne à transformer */
 char CH1[100]; /* chaîne à rechercher  */
 char CH2[100]; /* chaîne de remplacement */
 char FIN[100]; /* chaîne de sauvegarde pour */
                /* la fin de SUJ. */
 int I;      /* indice courant dans SUJ */
 int J;      /* indice courant dans CH1 et CH2 */
 int K;      /* indice d'aide pour les copies  */
 int TROUVE; /* indicateur logique qui précise */
             /* si la chaîne OBJ a été trouvée */

 /* Saisie des données */
 printf("Introduisez la chaîne à rechercher  CH1 : ");
 gets(CH1);
 printf("Introduisez la chaîne à remplacer   CH2 : ");
 gets(CH2);
 printf("Introduisez la chaîne à transformer SUJ : ");
 gets(SUJ);

 /* Recherche de CH1 dans SUJ */
 TROUVE=0;
 for (I=0; SUJ[I] && !TROUVE; I++)
    if (SUJ[I]==CH1[0])
        {
         for (J=1; CH1[J] && (CH1[J]==SUJ[I+J]); J++)
            ;
         if (CH1[J]=='\0') TROUVE=1;
        }


 /* Si CH1 a été trouvée dans SUJ alors sauvegarder la fin */
 /* de SUJ dans FIN, copier ensuite CH2 et FIN dans SUJ.   */
 if (TROUVE)
    {
     I--;
     /* Maintenant  I indique la position de CH1 */
     /* dans SUJ et J indique la longueur de CH1 */
     /* Sauvegarder la fin de SUJ dans FIN */
     for (K=0; SUJ[K+I+J]; K++)
          FIN[K]=SUJ[K+I+J];
     FIN[K]='\0';
     /* Copier CH2 dans SUJ */
     for (K=0; CH2[K]; K++,I++)
          SUJ[I]=CH2[K];
     /* Recopier FIN dans SUJ */
     for (K=0; FIN[K]; K++,I++)
          SUJ[I]=FIN[K];
     /* Terminer la chaîne SUJ */
     SUJ[I]='\0';
    }

 /* Affichage du résultat */
 printf("Chaîne résultat : \"%s\"\n", SUJ);
 return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#include <stdio.h>
main()
{
 /* Déclarations */
 char SUJ[100]; /* chaîne à  transformer */
 char CH1[100]; /* chaîne à  rechercher  */
 char CH2[100]; /* chaîne de remplacement */
 char FIN[100]; /* chaîne de sauvegarde pour */
                /* la fin de SUJ. */
 int I;      /* indice courant dans SUJ */
 int J;      /* indice courant dans CH1 et CH2 */
 int K;      /* indice d'aide pour les copies  */


 /* Saisie des données */
 printf("Introduisez la chaîne à rechercher  CH1 : ");
 gets(CH1);
 printf("Introduisez la chaîne à remplacer   CH2 : ");
 gets(CH2);
 printf("Introduisez la chaîne à transformer SUJ : ");
 gets(SUJ);

 /* Recherche de CH1 dans SUJ */
 for (I=0; SUJ[I]; I++)
    if (SUJ[I]==CH1[0])
       {
        for (J=1; CH1[J] && (CH1[J]==SUJ[I+J]); J++)
            ;
        if (CH1[J]=='\0') /* TROUVE ! */
          {
           /* Maintenant  I indique la position de CH1 */
           /* dans SUJ et J indique la longueur de CH1 */
           /* Sauvegarder la fin de SUJ dans FIN */
           for (K=0; SUJ[K+I+J]; K++)
              FIN[K]=SUJ[K+I+J];
           FIN[K]='\0';
           /* Copier CH2 dans SUJ et déplacer */
           /* I derrière la copie de CH2. */
           for (K=0; CH2[K]; K++,I++)
               SUJ[I]=CH2[K];
           /* Recopier FIN dans SUJ */
           for (K=0; FIN[K]; K++)
               SUJ[I+K]=FIN[K];
           /* Terminer la chaîne SUJ */
           SUJ[I+K]='\0';
           I--; /* réajustement de l'indice I */
          }
       }

 /* Affichage du résultat */
 printf("Chaîne résultat : \"%s\"\n", SUJ);
 return 0;
}