Exercices langage C pointeurs et chaînes de caractères

 


Exercice 1

Ecrire un programme qui lit deux tableaux d'entiers A et B et leurs dimensions N et M au clavier et qui ajoute les éléments de B à la fin de A. Utiliser deux pointeurs PA et PB pour le transfer et afficher le tableau résultant A.


Exercice 2

Ecrire de deux façons différentes, un programme qui vérifie sans utiliser une fonction de <string>, si une chaîne CH introduite au clavier est un palindrome:

a) en utilisant uniquement le formalisme tableau

b) en utilisant des pointeurs au lieu des indices numériques

Rappel: Un palindrome est un mot qui reste le même qu'on le lise de gauche à droite ou de droite à gauche:

Exemples:

PIERRE ==> n'est pas un palindrome
OTTO ==> est un palindrome
23432 ==> est un palindrome

Exercice 3

Ecrire un programme qui lit une chaîne de caractères CH et détermine la longueur de la chaîne à l'aide d'un pointeur P. Le programme n'utilisera pas de variables numériques.


Exercice 4

Ecrire un programme qui lit une chaîne de caractères CH et détermine le nombre de mots contenus dans la chaîne. Utiliser un pointeur P, une variable logique, la fonction isspace et une variable numérique N qui contiendra le nombre des mots.


Exercice 5

Ecrire un programme qui lit une chaîne de caractères CH au clavier et qui compte les occurrences des lettres de l'alphabet en ne distinguant pas les majuscules et les minuscules. Utiliser un tableau ABC de dimension 26 pour mémoriser le résultat et un pointeur PCH pour parcourir la chaîne CH et un pointeur PABC pour parcourir ABC. Afficher seulement le nombre des lettres qui apparaissent au mois une fois dans le texte.

Exemple:

 Entrez un ligne de texte (max. 100 caractères) : 
Jeanne
La chaîne "Jeanne" contient :
1 fois la lettre 'A'
2 fois la lettre 'E'
1 fois la lettre 'J'
3 fois la lettre 'N'

Exercice 6

Ecrire un programme qui lit un caractère C et une chaîne de caractères CH au clavier. Ensuite toutes les occurrences de C dans CH seront éliminées. Le reste des caractères dans CH sera tassé à l'aide d'un pointeur et de la fonction strcpy.


Exercice 7

Ecrire un programme qui lit deux chaînes de caractères CH1 et CH2 au clavier et élimine toutes les lettres de CH1 qui apparaissent aussi dans CH2. Utiliser deux pointeurs P1 et P2, une variable logique TROUVE et la fonction strcpy.

Exemples:

Bonjour Bravo ==> njou
Bonjour bravo ==> Bnjou
abacab aa ==> bcab

Exercice 8

Ecrire un programme qui lit deux chaînes de caractères CH1 et CH2 au clavier et supprime la première occurrence de CH2 dans CH1. Utiliser uniquement des pointeurs, une variable logique TROUVE et la fonction strcpy.

Exemples:

Alphonse phon ==> Alse
totalement t ==> otalement
abacab aa ==> abacab

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
#include <stdio.h>
main()
{
 /* Déclarations */
 int A[100], B[50]; /* tableaux */
 int N, M;    /* dimensions des tableaux */
 int *PA,*PB; /* pointeurs d'aide        */

  /* Saisie des données */
 printf("Dimension du tableau A (max.50) : ");
 scanf("%d", &N );
 for (PA=A; PA<A+N; PA++)
     {
      printf("Elément %d : ", PA-A);
      scanf("%d", PA);
     }
  printf("Dimension du tableau B (max.50) : ");
 scanf("%d", &M );
 for (PB=B; PB<B+M; PB++)
     {
      printf("Elément %d : ", PB-B);
      scanf("%d", PB);
     }
  /* Affichage des tableaux */
 printf("Tableau donné A :\n");
 for (PA=A; PA<A+N; PA++)
      printf("%d ", *PA);
  printf("\n");
 printf("Tableau donné B :\n");
 for (PB=B; PB<B+M; PB++)
      printf("%d ", *PB);
  printf("\n");
 /* Copier B à la fin de A */
 for (PA=A+N,PB=B ; PB<B+M ; PA++,PB++)
      *PA = *PB;
 /* Nouvelle dimension de A */
 N += M; 
  /* Edition du résultat */
 printf("Tableau résultat A :\n");
 for (PA=A; PA<A+N; PA++)
      printf("%d ", *PA);
 printf("\n");
 return 0;
}

 


a) en utilisant uniquement le formalisme tableau

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
#include <stdio.h>
main()
{
 /* Déclarations */
 char CH[101]; /* chaîne donnée    */
 int I,J;      /* indices courants */
 int PALI;     /* indicateur logique:          */ 
               /* vrai si CH est un palindrome */

  /* Saisie des données */
 printf("Entrez une ligne de texte (max.100 caractères) :\n");
 gets(CH);
 /* Placer J sur la dernière lettre de la chaîne */
 for(J=0; CH[J]; J++)
     ;
 J--;
 /* Contrôler si CH est un palindrome */
 PALI=1;
 for (I=0 ; PALI && I<J ; I++,J--)
      if (CH[I] != CH[J])
          PALI=0;

  /* Affichage du résultat */
 if (PALI)
    printf("La chaîne \"%s\" est un palindrome.\n", CH);
 else
    printf("La chaîne \"%s\" n'est pas un palindrome.\n", CH);
 return 0;
}



b) en utilisant des pointeurs au lieu des indices numériques :

 

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 CH[101];  /* chaîne donnée    */
 char *P1,*P2;  /* pointeurs d'aide */
  int PALI;  /* indicateur logique:          */
            /* vrai si CH est un palindrome */

  /* Saisie des données */
 printf("Entrez une ligne de texte (max.100 caractères) :\n");
 gets(CH);
 /* Placer P2 sur la dernière lettre de la chaîne */
 for (P2=CH; *P2; P2++)
      ;
 P2--;
 /* Contrôler si CH est un palindrome */
 PALI=1;
 for (P1=CH ; PALI && P1<P2 ; P1++,P2--)
      if (*P1 != *P2) PALI=0;
  /* Affichage du résultat */
 if (PALI)
    printf("La chaîne \"%s\" est un palindrome.\n", CH);
 else
    printf("La chaîne \"%s\" n'est pas un palindrome.\n", CH);
 return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>

main()
{
 /* Déclarations */
 char CH[101];  /* chaîne donnée   */
 char *P;       /* pointeur d'aide */

  /* Saisie des données */
 printf("Entrez une ligne de texte (max.100 caractères) :\n");
 gets(CH);
 /* Placer P à la fin de la chaîne */
 for (P=CH; *P; P++)
      ;
  /* Affichage du résultat */
 printf("La chaîne \"%s\" est formée de %d caractères.\n",
                                                     CH, P-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
#include <stdio.h>
#include <ctype.h>
 main()
{
 /* Déclarations */
 char CH[101]; /* chaîne donnée */
 char *P;      /* pointeur d'aide */
 int N;        /* nombre des mots */
 int DANS_MOT; /* indicateur logique: */
               /* vrai si P pointe à l'intérieur un mot */

 /* Saisie des données */
 printf("Entrez une ligne de texte (max.100 caractères) :\n");
 gets(CH);
 /* Compter les mots */
 N=0;
 DANS_MOT=0;
 for (P=CH; *P; P++)
     if (isspace(*P))
         DANS_MOT=0;
     else if (!DANS_MOT)
         {
          DANS_MOT=1;
          N++;
         }  
  /* Affichage du résultat (pour perfectionnistes) */
 printf("La chaîne \"%s\" \nest formée de %d mot%c.\n",
                                        CH, N, (N==1)?' ':'s');
 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
#include <stdio.h>
main()
{
 /* Déclarations */
 char CH[101]; /* chaîne donnée */
 char *PCH;    /* pointeur d'aide dans CH  */
 int ABC[26];  /* compteurs des différents caractères */
  int *PABC;    /* pointeur d'aide dans ABC */

 /* Saisie des données */
 printf("Entrez une ligne de texte (max.100 caractères) :\n");
 gets(CH);
 /* Initialiser le tableau ABC */
 for (PABC=ABC; PABC<ABC+26; PABC++)
     *PABC=0;
 /* Compter les lettres */
 for (PCH=CH; *PCH; PCH++)
     {
      if (*PCH>='A' && *PCH<='Z')
         (*(ABC+(*PCH-'A')))++; /* Attention aux parenthèses! */
      if (*PCH>='a' && *PCH<='z')
         (*(ABC+(*PCH-'a')))++;
     }
 /* Affichage des résultats */ 
 /* (PABC-ABC) est le numéro de la lettre de l'alphabet. */
 printf("La chaîne \"%s\" contient :\n", CH);
 for (PABC=ABC; PABC<ABC+26; PABC++)
     if (*PABC)
        printf(" %d\tfois la lettre '%c' \n",
                                        *PABC, 'A'+(PABC-ABC));
  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
#include <stdio.h>
#include <string.h>
 main()
{
 /* Déclarations */
 char CH[101]; /* chaîne donnée */
 char C;   /* lettre à éliminer */
 char *P;  /* pointeur d'aide dans CH */

 /* Saisie des données */
 printf("Entrez une ligne de texte (max.100 caractères)  :\n");
 gets(CH);
 printf("Entrez le caractère à éliminer (suivi de Enter) : ");
 C=getchar();
 /* Comprimer la chaîne à l'aide de strcpy */
 P=CH;
 while (*P)
   {
      if (*P==C)
          strcpy(P, P+1);
      else P++;
   }

  /* Affichage du résultat */
 printf("Chaîne résultat : \"%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
32
33
34
35
36
#include <stdio.h>
#include <string.h>
 main()
{
 /* Déclarations */
 char CH1[101], CH2[101]; /* chaînes données */
 char *P1, *P2; /* pointeurs d'aide dans CH1 et CH2 */
 int TROUVE; /* indicateur logique: vrai, si le caractère */
             /* actuel dans CH1 a été trouvé dans CH2.    */

 /* Saisie des données */
 printf("Entrez la première chaîne de caractères"
        " (max.100 caractères) :\n");
 gets(CH1);
 printf("Entrez la deuxième chaîne de caractères"
        " (max.100 caractères) :\n");
 gets(CH2);
 /* Eliminer les lettres communes */
 /* Idée: Parcourir CH2 de gauche à droite et contrôler  */
 /* pour chaque caractère s'il se trouve aussi dans CH1. */
 /* Si tel est le cas, éliminer le caractère de CH1 à    */
 /* l'aide de strcpy. */
 for (P2=CH2; *P2; P2++)
     {
      TROUVE = 0;
      for (P1=CH1 ; *P1 && !TROUVE ; P1++)
           if (*P2==*P1)
               {
                TROUVE = 1;
                strcpy(P1, P1+1);
               }
     }
  /* Affichage du résultat */
 printf("Chaîne résultat : \"%s\" \n", 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
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#include <stdio.h>
#include <string.h>
 main()
{
 /* Déclarations */
 char CH1[101], CH2[101]; /* chaînes données */
 char *P1, *P2; /* pointeurs d'aide dans CH1 et CH2 */
 int TROUVE; /* indicateur logique: vrai, si le caractère */
             /* actuel dans CH1 a été trouvé dans CH2.    */

 /* Saisie des données */
 printf("Entrez la chaîne à transformer"
        " (max.100 caractères) :\n");
 gets(CH1);
 printf("Entrez la chaîne à supprimer  "
        " (max.100 caractères) :\n");
 gets(CH2);
 /* Rechercher CH2 dans CH1 : */
 /* L'expression P2-CH2 est utilisée pour déterminer l'indice */
 /* de P2 dans CH2. On pourrait aussi résoudre le problème à  */
 /* l'aide d'un troisième pointeur P3 parcourant CH1. */
 TROUVE=0;
 for (P1=CH1 ; *P1 && !TROUVE ; P1++)
     {
      for (P2=CH2 ; *P2 == *(P1+(P2-CH2)) ; P2++)
          ;
      if (!*P2)
          TROUVE = 1;
     }

 /* A la fin de la boucle, P1 est incrémenté, donc */
 P1--; 
 /* Si CH2 se trouve dans CH1, alors P1 indique la position */
 /* de la première occurence de CH2 dans CH1 et P2 pointe à */
 /* la fin de CH2. (P2-CH2) est alors la longueur de CH2.   */  
 if (TROUVE)
     strcpy(P1, P1+(P2-CH2));

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