Exercice 1

int LONG_CH(char *CH)
{
 char *P;
 for (P=CH ; *P; P++) ;
 return P-CH;
}

Exercice 2

void MAJ_CH(char *CH)
{
 for ( ; *CH; CH++)
      if (*CH>='a' && *CH<='z')
          *CH = *CH-'a'+'A';
}

Exercice 3

void AJOUTE_CH(char *CH1, char *CH2)
{
 while (*CH1) /* chercher la fin de CH1 */
        CH1++;
 while (*CH2) /* copier CH2 à la fin de CH1 */
       {
        *CH1 = *CH2;
        CH1++;
        CH2++;
       }
 *CH1=''; /* terminer la chaîne CH1 */
}

Solution plus compacte :

void AJOUTE_CH(char *CH1, char *CH2)
{
 for ( ; *CH1 ; CH1++) ;
 for ( ; *CH1 = *CH2 ; CH1++, CH2++) ;
}

Comme la condition d’arrêt est évaluée lors de l’affectation, le symbole de fin de chaîne est aussi copié.

Exercice 4

void INVERSER_CH (char *CH)
{
 /* Prototypes des fonctions appelées */
 int LONG_CH(char *CH);
 void PERMUTER_CH(char *A, char *B);
 /* Variables locales */
 int I,J;
 /* Inverser la chaîne par permutations successives */
 J = LONG_CH(CH)-1;
 for (I=0 ; I<J ; I++,J--)
      PERMUTER_CH(CH+I, CH+J);
}

void PERMUTER_CH(char *A, char *B)
{
 char AIDE;
 AIDE = *A;
 *A   = *B;
 *B   = AIDE;
}

int LONG_CH(char *CH)
{
 . . .
}

Exercice 5

#include <ctype.h>

int NMOTS_CH(char *CH)
{
 /* Variables locales */
 int N;        /* nombre de mots */
 int DANS_MOT; /* indicateur logique : */
               /* vrai si CH pointe à l'intérieur d'un mot */
 DANS_MOT=0;
 for (N=0; *CH; CH++)
     if (isspace(*CH))
         DANS_MOT=0;
     else if (!DANS_MOT)
         {
          DANS_MOT=1;
          N++;
         }
 return N;
}

Exercice 6

#include <ctype.h>

char *MOT_CH(int N, char *CH)
{
 /* Variables locales */
 int DANS_MOT; /* indicateur logique : */
               /* vrai si CH pointe à l'intérieur d'un mot */
 DANS_MOT=0;
 for ( ; N>0 && *CH ; CH++)
     if (isspace(*CH))
         DANS_MOT=0;
     else if (!DANS_MOT)
         {
          DANS_MOT=1;
          N--;
          CH--; /* Pour réajuster l'effet de l'incrémentation */
         }
 return CH;
}

Exercice 7

int EGAL_N_CH(int N, char *CH1, char *CH2)
{
 while (--N && *CH1==*CH2)
    {
     CH1++;
     CH2++;
    }
 return (*CH1==*CH2);
}

Exercice 8

char *CHERCHE_CH(char *CH1, char *CH2)
{
 /* Prototypes des fonctions appelées */
 int LONG_CH(char *CH);
 int EGAL_N_CH(int N, char *CH1, char *CH2);
 /* Variables locales */
 int L;
 /* Recherche de CH1 dans CH2 */
 L=LONG_CH(CH1);
 while (*CH2 && !EGAL_N_CH(L, CH1, CH2))
          CH2++;
 return CH2;
}

int LONG_CH(char *CH)
{
 . . .
}

int EGAL_N_CH(int N, char *CH1, char *CH2)
{
 . . .
}

Exercice 9

long CH_ENTIER(char *CH)
{
 /* Variables locales */
 long N;
 int SIGNE;
 /* Traitement du signe */
 SIGNE = 1;
 if (*CH=='-') SIGNE = -1;
 if (*CH=='-' || *CH=='+') CH++;
 /* Conversion des chiffres */ 
 for (N=0 ; *CH>='0' && *CH<='9' ; CH++)
         N = N*10 + (*CH-'0');
 return SIGNE*N;
}

Exercice 10

#include <ctype.h>
#include <math.h>

double CH_DOUBLE(char *CH)
{
 /* Variables locales */
 double N; /* résultat numérique */
 int SIGNE; /* signe de la valeur rationnelle */
 int DEC; /* positions derrière la virgule  */

 /* Initialisation des variables */
 N = 0.0;
 SIGNE = 1;
 /* Traitement du signe */
 if (*CH=='-') SIGNE = -1;
 if (*CH=='-' || *CH=='+') CH++;
 /* Positions devant le point décimal */
 for ( ; isdigit(*CH); CH++)
     N = N*10.0 + (*CH-'0');
 /* Traitement du point décimal */
 if (*CH=='.') CH++;

 /* Traitement des positions derrière le point décimal */
 for (DEC=0; isdigit(*CH); CH++)
    {
     N = N*10.0 + (*CH-'0');
     DEC++;
    }
 /* Calcul de la valeur à partir du signe et */
 /* du nombre de décimales. */
 return SIGNE*N/pow(10,DEC);
}

Exercice 11

#include <stdio.h>

void ENTIER_CH(long N, char *CH)
{
  /* Prototypes des fonctions appelées */
 void INVERSER_CH(char *CH);
 /* Variables locales */
 int I;
 int SIGNE;
 /* Traitement du signe */
 SIGNE = (N<0) ? -1 : 1;
 if (N<0) N=-N;
 /* Conversion des chiffres (à rebours) */
 I=0;
 do
    {
     *(CH+I) = N % 10 + '0';
     I++;
    }
 while ((N/=10) > 0);
 /* Ajouter le signe à la fin de la chaîne */
 if (SIGNE<0)
    {
     *(CH+I)='-';
     I++;
    }
 /* Terminer la chaîne */
 *(CH+I)='';
 /* Inverser la chaîne */
 INVERSER_CH(CH);
}

void INVERSER_CH (char *CH)
{
 /* Prototypes des fonctions appelées */
 int LONG_CH(char *CH);
 void PERMUTER_CH(char *A, char *B);
 . . .
}

int LONG_CH(char *CH)
{
 . . .
}

void PERMUTER_CH(char *A, char *B)
{
 . . .
}

Exercice 12

void DOUBLE_CH(double N, char *CH)

{ /* Prototypes des fonctions appelées */
 int LONG_CH(char *CH); 
void ENTIER_CH(long N, char *CH); 
/* Variables locales */ 
int I,L; 
/* Conversion */ 
N *= 10000.0; 
ENTIER_CH((long)N, CH); 
/* Conversion forcée est facultative */ 
L=LONG_CH(CH); for (I=L; I>=L-4; I--) 
/* Libérer une position pour le */
 *(CH+I+1) = *(CH+I); 
/* point décimal. */
 *(CH+L-4)='.'; 
} 
void ENTIER_CH(long N, char *CH) 
{ 
/* Prototypes des fonctions appelées */ 
void INVERSER_CH(char *CH);
 . . . } 
void INVERSER_CH (char *CH) { 
/* Prototypes des fonctions appelées */
 int LONG_CH(char *CH); 
void PERMUTER_CH(char *A, char *B);
 . . . } 
int LONG_CH(char *CH) { . . . } 
void PERMUTER_CH(char *A, char *B) { . . . }