Exercice langage C corrigé les fichiers séquentiels

Exercice 1

#include <stdio.h>
#include <stdlib.h>
main()
{
  /* Déclarations : */
  /* Nom du fichier et pointeur de référence */
  char NOM_FICH[] = "A:\\INFORM.TXT"; 
  FILE *FICHIER;
   /* Autres variables */
  char NOM[30], PRENOM[30];
  int MATRICULE;
  int I,N_ENR;

  /* Ouverture du nouveau fichier en écriture */
  FICHIER = fopen(NOM_FICH, "w");
  if (!FICHIER)
     {  
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", NOM_FICH);
      exit(-1);
     }
   /* Saisie des données et création du fichier */
  printf("*** Création du fichier %s ***\n", NOM_FICH);
  printf("Nombre d'enregistrements à créer : ");
  scanf("%d",&N_ENR);
  for (I=1; I<=N_ENR; I++)
    {
     printf("Enregistrement No: %d \n", I);
     printf("Numéro de matricule : ");
     scanf("%d",&MATRICULE);      
     printf("Nom    : ");
     scanf("%s",NOM);
     printf("Prénom : ");
     scanf("%s",PRENOM);
     fprintf(FICHIER, "%d\n%s\n%s\n", MATRICULE, NOM, PRENOM);
     }
  /* Fermeture du fichier */
  fclose(FICHIER);

  /* Ouverture du fichier en lecture */
  FICHIER = fopen(NOM_FICH, "r");
  if (!FICHIER)
     {  
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", NOM_FICH);
      exit(-1);
     }
   /* Affichage du fichier */
  printf("*** Contenu du fichier  %s ***\n", NOM_FICH);
  while (!feof(FICHIER))
    {
     fscanf(FICHIER, "%d\n%s\n%s\n", &MATRICULE, NOM, PRENOM);
     printf("Matricule : %d\t", MATRICULE);
     printf("Nom et prénom : %s %s\n", NOM, PRENOM);
    }
  /* Fermeture du fichier */
  fclose(FICHIER);
   return 0;
}

 Exercice 2

#include <stdio.h>
#include <stdlib.h>
main()
{
  /* Déclarations : */
  /* Noms des fichiers et pointeurs de référence */
  char ANCIEN[]  = "A:\\INFORM.TXT";
  char NOUVEAU[] = "A:\\INFBIS.TXT"; 
  FILE *INFILE, *OUTFILE;
   /* Autres variables */
  char NOM[30], PRENOM[30];
  int MATRICULE;

  /* Ouverture de l'ancien fichier en lecture */
  INFILE = fopen(ANCIEN, "r");
   if (!INFILE)
     { 
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", ANCIEN);
      exit(-1);
     }
  /* Ouverture du nouveau fichier en écriture */
  OUTFILE = fopen(NOUVEAU, "w");
   if (!OUTFILE)
     { 
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", NOUVEAU);
      exit(-1);
     }

  /* Copie de tous les enregistrements */
  while (!feof(INFILE))
    {
     fscanf (INFILE, "%d\n%s\n%s\n", &MATRICULE, NOM, PRENOM);
     fprintf(OUTFILE, "%d\n%s\n%s\n", MATRICULE, NOM, PRENOM);
    }
 /* Fermeture des fichiers */
 fclose(OUTFILE);
 fclose(INFILE);
  return 0;
}

 Exercice 3

#include <stdio.h>
#include <stdlib.h>
main()
{
  /* Déclarations : */
  /* Noms des fichiers et pointeurs de référence */
  char ANCIEN[]  = "A:\\INFORM.TXT";
  char NOUVEAU[] = "A:\\INFBIS.TXT"; 
  FILE *INFILE, *OUTFILE;
  /* Autres variables */
  char NOM[30], PRENOM[30];

  int MATRICULE;
  char NOM_NOUV[30], PRE_NOUV[30];
  int MATRI_NOUV;
  /* Ouverture de l'ancien fichier en lecture */
  INFILE = fopen(ANCIEN, "r");
   if (!INFILE)
     { 
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", ANCIEN);
      exit(-1);
     }
  /* Ouverture du nouveau fichier en écriture */
  OUTFILE = fopen(NOUVEAU, "w");
   if (!OUTFILE)
     { 
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", NOUVEAU);
      exit(-1);
     }

  /* Saisie de l'enregistrement à ajouter */
  printf("Enregistrement à ajouter : \n");
  printf("Numéro de matricule : ");
  scanf("%d",&MATRI_NOUV);      
  printf("Nom    : ");
  scanf("%s",NOM_NOUV);
  printf("Prénom : ");
  scanf("%s",PRE_NOUV);
  /* Copie des enregistrements de l'ancien fichier */
  while (!feof(INFILE))
    {
     fscanf (INFILE, "%d\n%s\n%s\n", &MATRICULE, NOM, PRENOM);
     fprintf(OUTFILE, "%d\n%s\n%s\n", MATRICULE, NOM, PRENOM);
    }
  /* Ecriture du nouvel enregistrement à la fin du fichier */
  fprintf(OUTFILE,"%d\n%s\n%s\n",MATRI_NOUV,NOM_NOUV,PRE_NOUV);
  /* Fermeture des fichiers */
  fclose(OUTFILE);
  fclose(INFILE);
   return 0;
}

 Exercice 4

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
main()
{
  /* Déclarations : */
  /* Noms des fichiers et pointeurs de référence */
  char ANCIEN[]  = "A:\\INFORM.TXT";
  char NOUVEAU[] = "A:\\INFBIS.TXT"; 
  FILE *INFILE, *OUTFILE;
  /* Autres variables */
  char NOM[30], PRENOM[30];
  int MATRICULE;
  char NOM_NOUV[30], PRE_NOUV[30];
  int MATRI_NOUV;
  int TROUVE;

  /* Ouverture de l'ancien fichier en lecture */
  INFILE = fopen(ANCIEN, "r");
   if (!INFILE)
     { 
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", ANCIEN);
      exit(-1);
     }

  /* Ouverture du nouveau fichier en écriture */
  OUTFILE = fopen(NOUVEAU, "w");
   if (!OUTFILE)
     { 
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", NOUVEAU);
      exit(-1);
     }

  /* Saisie de l'enregistrement à insérer */
  printf("Enregistrement à ajouter : \n");
  printf("Numéro de matricule : ");
  scanf("%d",&MATRI_NOUV);      
  printf("Nom    : ");
  scanf("%s",NOM_NOUV);
  printf("Prénom : ");
  scanf("%s",PRE_NOUV);

  /* Copie des enregistrements dont le nom */
  /* précéde lexicogr. celui à insérer.    */
  TROUVE = 0;
  while (!feof(INFILE) && !TROUVE)
    {
     fscanf (INFILE, "%d\n%s\n%s\n", &MATRICULE, NOM, PRENOM);
     if (strcmp(NOM, NOM_NOUV) > 0)
         TROUVE = 1;
     else
         fprintf(OUTFILE, "%d\n%s\n%s\n", MATRICULE,NOM,PRENOM);
    }

  /* Ecriture du nouvel enregistrement, */
  fprintf(OUTFILE,"%d\n%s\n%s\n",MATRI_NOUV,NOM_NOUV,PRE_NOUV);
  /* et du dernier enregistrement lu. */
  if (TROUVE)
      fprintf(OUTFILE, "%d\n%s\n%s\n", MATRICULE, NOM, PRENOM);

  /* Copie du reste des enregistrements */
  while (!feof(INFILE))
    {
     fscanf (INFILE, "%d\n%s\n%s\n", &MATRICULE, NOM, PRENOM);
     fprintf(OUTFILE, "%d\n%s\n%s\n", MATRICULE, NOM, PRENOM);
    }

  /* Fermeture des fichiers */
  fclose(OUTFILE);
  fclose(INFILE);
   return 0;
}

 Exercice 5

a) Supprimer les enregistrements, dont le numéro de matricule se termine par 8

#include <stdio.h>
#include <stdlib.h>
main()
{
  /* Déclarations : */
  /* Noms des fichiers et pointeurs de référence */
  char ANCIEN[]  = "A:\\INFORM.TXT";
  char NOUVEAU[] = "A:\\INFBIS.TXT"; 
  FILE *INFILE, *OUTFILE;
  /* Autres variables */
  char NOM[30], PRENOM[30];
  int MATRICULE;

  /* Ouverture de l'ancien fichier en lecture */
  INFILE = fopen(ANCIEN, "r");
   if (!INFILE)
     { 
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", ANCIEN);
      exit(-1);
     }
  /* Ouverture du nouveau fichier en écriture */
  OUTFILE = fopen(NOUVEAU, "w");
   if (!OUTFILE)
     { 
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", NOUVEAU);
      exit(-1);
     }
  /* Copie de tous les enregistrements à l'exception */
  /* de ceux dont le numéro de matricule se termine  */
  /* par 8. */
  while (!feof(INFILE))
    {
     fscanf (INFILE, "%d\n%s\n%s\n", &MATRICULE, NOM, PRENOM);
     if (MATRICULE%10 != 8)
        fprintf(OUTFILE, "%d\n%s\n%s\n", MATRICULE,NOM,PRENOM);
    }
  /* Fermeture des fichiers */
  fclose(OUTFILE);
  fclose(INFILE);
   return 0;
}

b) Supprimer les enregistrements, dont le prénom est « Paul » (utiliser strcmp)#include <stdio.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 main()
{
  /* Déclarations */
  . . .
  /* Ouverture de l'ancien fichier en lecture */
  . . .
  /* Ouverture du nouveau fichier en écriture */
  . . .
  /* Copie de tous les enregistrements à l'exception */
  /* de ceux dont le prénom est 'Paul'. */
  while (!feof(INFILE))
    {
     fscanf (INFILE, "%d\n%s\n%s\n", &MATRICULE, NOM, PRENOM);
     if (strcmp(PRENOM,"Paul") != 0)
        fprintf(OUTFILE, "%d\n%s\n%s\n", MATRICULE,NOM,PRENOM);
    }
   /* Fermeture des fichiers */
  . . .
}

c) Supprimer les enregistrements, dont le nom est un palindrome. Définir une fonction d’aide PALI qui fournit le résultat 1 si la chaîne transmise comme paramètre est un palindrome, sinon la valeur zéro.

#include <stdio.h>
#include <stdlib.h>
main()
{
  /* Prototype de la fonction PALI */
  int PALI(char *CH);
   /* Déclarations */
  . . .
  /* Ouverture de l'ancien fichier en lecture */
   . . .
  /* Ouverture du nouveau fichier en écriture */
  . . .
  /* Copie de tous les enregistrements à l'exception */
  /* des palindromes. */
  while (!feof(INFILE))
    {
     fscanf (INFILE, "%d\n%s\n%s\n", &MATRICULE, NOM, PRENOM);
     if (!PALI(NOM))
        fprintf(OUTFILE, "%d\n%s\n%s\n", MATRICULE,NOM,PRENOM);
    }
   /* Fermeture des fichiers */
  . . .
} 
int PALI(char *CH)
{
 /* Variable locale */
 char *CH2;
 /* Placer CH2 à la fin de la chaîne */
 for (CH2=CH; *CH2; CH2++)
     ;
 CH2--;
 /* Contrôler si la chaîne désignée par CH est un palindrome */
 for (; CH<CH2; CH++,CH2--)
      if (*CH != *CH2) return 0;
 return 1;
}

Exercice 6

#include <stdio.h>
#include <stdlib.h>
main()
{
  /* Déclarations : */
  /* Nom du fichier et pointeur de référence */
  char NOM_FICH[] = "A:\\FAMILLE.TXT"; 
  FILE *FICHIER;
  /* Autres variables */
  char NOM[30], PERE[30], MERE[30], ENFANT[30];
  int J,N_ENFANTS;
  int I,N_ENR;

  /* Ouverture du nouveau fichier en écriture */
  FICHIER = fopen(NOM_FICH, "w");
   if (!FICHIER)
     {  
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", NOM_FICH);
      exit(-1);
     }

  /* Saisie des données et création du fichier */
  printf("*** Création du fichier %s ***\n", NOM_FICH);
  printf("Nombre d'enregistrements à créer : ");
  scanf("%d",&N_ENR);
  for (I=1; I<=N_ENR; I++)
    {
     printf("Enregistrement No: %d \n", I);
     printf("Nom de famille : ");
     scanf("%s", NOM);      
     printf("Prénom du père : ");
     scanf("%s", PERE);
     printf("Prénom de la mère : ");
     scanf("%s", MERE);
     printf("Nombre d'enfants : ");
     scanf("%d", &N_ENFANTS);
     fprintf(FICHIER, "%s\n%s\n%s\n%d\n",
                                   NOM, PERE, MERE, N_ENFANTS);
     for (J=1; J<=N_ENFANTS; J++)
         {
          printf("Prénom %d. enfant : ", J);
          scanf("%s", ENFANT);
          fprintf(FICHIER, "%s\n", ENFANT);
         }
    }
  /* Fermeture du fichier */
  fclose(FICHIER);
  /* Réouverture du fichier */
  FICHIER = fopen(NOM_FICH, "r");
   if (!FICHIER)
     {  
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", NOM_FICH);
      exit(-1);
     }
  /* Affichage du fichier */
  printf("*** Contenu du fichier  %s ***\n", NOM_FICH);
  while (!feof(FICHIER))
    {
     fscanf (FICHIER, "%s\n%s\n%s\n%d\n",
                                   NOM, PERE, MERE, &N_ENFANTS);
      printf("\n");
     printf("Nom de famille : %s\n", NOM);
     printf("Nom du père    : %s %s\n", PERE, NOM);
     printf("Nom de la mère : %s %s\n", MERE, NOM);
     printf("Noms des enfants : \n", N_ENFANTS);
     for (J=1; J<=N_ENFANTS; J++)
         {
          fscanf(FICHIER, "%s\n", ENFANT);
          printf("\t%d. : %s %s\n", J, ENFANT, NOM);
         }
    }
  /* Fermeture du fichier */
  fclose(FICHIER);
   return 0;
}

 Exercice 7

#include <stdio.h>
#include <stdlib.h>
main()
{
  /* Déclarations : */
  /* Nom du fichier et pointeur de référence */
  char NOM_FICH[] = "A:\\MOTS.TXT"; 
  FILE *FICHIER;
  /* Autres variables */
  char CHAINE[50];

  /* Ouverture du nouveau fichier en écriture */
  FICHIER = fopen(NOM_FICH, "w");
   if (!FICHIER)
     {  
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", NOM_FICH);
      exit(-1);
     }
  /* Saisie des données et création du fichier */
  printf("*** Création du fichier %s ***\n", NOM_FICH);
  do
    {
     printf("Entrez un mot ('*' pour finir) : ");
     scanf("%s", CHAINE);
     if (CHAINE[0] != '*')
         fprintf(FICHIER, "%s\n", CHAINE);
    }
  while (CHAINE[0] != '*');
  /* Fermeture du fichier */
  fclose(FICHIER);
   return 0;
}

 Exercice 8

#include <stdio.h>
#include <stdlib.h>
main()
{
  /* Prototypes des fonctions appelées */
  int PALI(char *CH);
  int LONG_CH(char *CH);
   /* Déclarations : */
  /* Nom du fichier et pointeur de référence */
  char NOM_FICH[] = "A:\\MOTS.TXT"; 
  FILE *FICHIER;
  /* Autres variables */
  char CHAINE[50];
  int N_PALI; /* nombre de palindromes */
  int N_MOTS; /* nombre de mots */
  int L_TOT;  /* longueur totale de tous les mots */

  /* Ouverture du nouveau fichier en écriture */
  FICHIER = fopen(NOM_FICH, "r");
   if (!FICHIER)
     {  
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", NOM_FICH);
      exit(-1);
     }
  /* Compter les palindromes et accumuler */
  /* les longueurs des mots. */
  L_TOT =0;
  N_PALI=0;
  N_MOTS=0;
  while (!feof(FICHIER))
    {
     fscanf(FICHIER, "%s\n", CHAINE);
     N_MOTS++;
     L_TOT  += LONG_CH(CHAINE);
     N_PALI += PALI(CHAINE);
    }
   /* Fermeture du fichier */
  fclose(FICHIER);
   /* Affichage des résultats */
  printf("Le fichier %s contient :\n", NOM_FICH);
  printf("\t%d \tmots d'une longueur moyenne de :\n", N_MOTS);
  printf("\t%.1f \tcaractères et\n", (float)L_TOT/N_MOTS);
  printf("\t%d \tpalindromes\n", N_PALI);
  return 0;
}
int PALI(char *CH)
{
 /* Variable locale */
 char *CH2;
 /* Placer CH2 à la fin de la chaîne */
 for (CH2=CH; *CH2; CH2++)
     ;
 CH2--;
 /* Contrôler si la chaîne désignée par CH est un palindrome */
 for (; CH<CH2; CH++,CH2--)
      if (*CH != *CH2) return 0;
 return 1;
}
int LONG_CH(char *CH)
{
 char *P;
 for (P=CH ; *P; P++) ;
 return P-CH;
}

 Exercice 9

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
main()
{
  /* Déclarations : */
  /* Noms des fichiers et pointeurs de référence */
  char ANCIEN[]  = "A:\\MOTS.TXT";
  char NOUVEAU[] = "A:\\MOTS_TRI.TXT"; 
  FILE *INFILE, *OUTFILE;
  /* Tableau de pointeurs */
  char *TAB[50];
  /* Autres variables */
  char CHAINE[50];
  char *AIDE; /* pour la permutation */ 
  int N_MOTS; /* nombre de mots du fichier */
  int I; /* ligne à partir de laquelle TAB est trié */
  int J; /* indice courant */
  int FIN; /* ligne où la dernière permutation a eu lieu */
    /* permet de ne pas trier un sous-ensemble déjà trié */

  /* Ouverture de l'ancien fichier en lecture */
  INFILE = fopen(ANCIEN, "r");
   if (!INFILE)
     { 
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", ANCIEN);
      exit(-1);
     }
  /* Initialisation du du compteur des mots */
  N_MOTS = 0;
  /* Lecture du fichier dans la mémoire centrale */
  while (!feof(INFILE))
     {
      fscanf (INFILE, "%s\n", CHAINE);
      /* Réservation de la mémoire */
      TAB[N_MOTS] = malloc(strlen(CHAINE)+1);
      if (TAB[N_MOTS])
          strcpy(TAB[N_MOTS], CHAINE);
      else
          {
           printf("\aPas assez de mémoire \n");
           exit(-1);
          }
      N_MOTS++;
     }
  /* Fermeture du fichier */
  fclose(INFILE);
  /* Tri du tableau par propagation de l'élément maximal. */
  for (I=N_MOTS-1 ; I>0 ; I=FIN)
      {
       FIN=0;
       for (J=0; J<I; J++)
           if (strcmp(TAB[J],TAB[J+1])>0)
             {
              FIN=J;
              AIDE     = TAB[J];
              TAB[J]   = TAB[J+1];
              TAB[J+1] = AIDE;
             }
      }
   /* Ouverture du nouveau fichier en écriture */
  OUTFILE = fopen(NOUVEAU, "w");
   if (!OUTFILE)
     { 
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", NOUVEAU);
      exit(-1);
     }
  /* Copie du tableau dans le nouveau fichier */
  for (I=0; I<N_MOTS; I++)
       fprintf(OUTFILE, "%s\n", TAB[I]);
  /* Fermeture du fichier */
  fclose(OUTFILE);
   return 0;
}

 Exercice 10

#include <stdio.h>
#include <stdlib.h>
main()
{
  /* Déclarations : */
  /* Noms des fichiers et pointeurs de référence */
  char NOM_FICH[]  = "A:\\NOMBRES.TXT";
  FILE *FICHIER;
  /* Autres variables */
  int NOMBRE; /* nombre actuel lu dans le fichier */
  int N;      /* compteur des nombres */
  long SOMME; /* somme des nombres */

  /* Ouverture de l'ancien fichier en lecture */
  FICHIER = fopen(NOM_FICH, "r");
   if (!FICHIER)
     { 
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", NOM_FICH);
      exit(-1);
     }
  /* Lecture du fichier et comptabilité */
  N=0;
  SOMME=0;
  while (!feof(FICHIER))
     {
      fscanf (FICHIER, "%d\n", &NOMBRE);
      SOMME += NOMBRE;
      N++;
     }
  /* Fermeture du fichier */
  fclose(FICHIER);
   /* Affichage des résultats */
  printf("Le fichier %s contient %d nombres.\n", NOM_FICH, N);
  printf("La somme des nombres est   : %ld\n", SOMME);
  printf("La moyenne des nombres est : %f\n", (float)SOMME/N);
  return 0;
}

 Exercice 11

#include <stdio.h>

main()
{
  /* Déclarations : */
  /* Noms des fichiers et pointeurs de référence */
  char ANCIEN[30], NOUVEAU[30]; 
  FILE *INFILE, *OUTFILE;
  /* Autres variables */
  char C; /* caractère lu dans le fichier */
  char N_RET; /* Compteur des retours à la ligne consécutifs */

  /* Ouverture de l'ancien fichier en lecture */
  do
    {
     printf("Nom du fichier source : ");
     scanf("%s", ANCIEN);
     INFILE = fopen(ANCIEN, "r"); 
     if (!INFILE) 
         printf("\aERREUR: Impossible d'ouvrir "
                "le fichier: %s.\n", ANCIEN);
    }
  while (!INFILE);
   /* Ouverture du nouveau fichier en écriture */
  do
    {
     printf("Nom du nouveau fichier : ");
     scanf("%s", NOUVEAU);
     OUTFILE = fopen(NOUVEAU, "w"); 
     if (!OUTFILE) 
         printf("\aERREUR: Impossible d'ouvrir "
                "le fichier: %s.\n", NOUVEAU);
    }
  while (!OUTFILE);

  /* Copier tous les caractères et remplacer le */
  /* premier retour à la ligne d'une suite par  */
  /* un espace. */ 
  N_RET=0;
  while (!feof(INFILE))
    {
     C=fgetc(INFILE);
     if (!feof(INFILE))
        {
         if (C == '\n')
            {
             N_RET++;
             if (N_RET > 1)
                fputc('\n', OUTFILE);
             else
                fputc(' ', OUTFILE);
            }
         else
            {
             N_RET=0; 
             fputc(C, OUTFILE);
            }
        }
    }
   /* Fermeture des fichiers */
  fclose(OUTFILE);
  fclose(INFILE);
   return 0;
} 

Remarque :

Après la lecture par fgetc, il faut sassurer encore une fois que le caractère lu est différent de EOF. Nous obtenons ainsi une construction un peu lourde:

   while (!feof(INFILE))
     {
      C=fgetc(INFILE);
      if (!feof(INFILE))
         {
          . . .
         }
     }

Il est possible de réunir plusieurs instructions dans le bloc conditionnel de la structure while, en les séparant par des virgules. En pratique, on retrouve cette solution souvent pour éviter des constructions inutilement lourdes:

   while (C=fgetc(INFILE), !feof(INFILE))
     {
          . . .
     }

 Exercice 12

#include <stdio.h>
main()
{
  /* Prototype de la fonction FIN_PHRASE */
  int FIN_PHRASE(char C);
   /* Déclarations : */
  /* Noms des fichiers et pointeurs de référence */
  char NOM_FICH[30]; 
  FILE *FICHIER;
  /* Autres variables */
  char C; /* caractère lu dans le fichier */
  char NP; /* Compteur de phrases */

  /* Ouverture de l'ancien fichier en lecture */
  do
    {
     printf("Nom du fichier texte : ");
     scanf("%s", NOM_FICH);
     FICHIER = fopen(NOM_FICH, "r"); 
      if (!FICHIER) 
         printf("\aERREUR: Impossible d'ouvrir "
                "le fichier: %s.\n", NOM_FICH);
    }
  while (!FICHIER);
  /* Compter les symboles de fin de phrase */
  NP=0;
  while (!feof(FICHIER))
        NP += FIN_PHRASE(fgetc(FICHIER));
   /* Fermeture du fichier */
  fclose(FICHIER);
   /* Affichage du résultat */
  printf("Le fichier %s contient %d phrases.\n",  NOM_FICH, NP);
  return 0;
} 

int FIN_PHRASE(char C)
{
 return (C=='.' || C=='!' || C=='?');
}

 Exercice 13

#include <stdio.h>
main()
{
  /* Prototype de la fonction FIN_PHRASE */
  int SEPA(char C);
   /* Déclarations : */
  /* Noms des fichiers et pointeurs de référence */
  char NOM_FICH[30]; 
  FILE *FICHIER;

  /* Autres variables */
  char C;       /* caractère lu dans le fichier */
  int ABC[26];  /* compteurs des lettres de l'alphabet */
   int NTOT;     /* nombre total des caractères */
  int NAUTRES;  /* nombre des caractères qui ne font pas
                   partie de l'alphabet */
  int NMOTS;    /* nombre des mots */
  int NPARA;    /* nombre de paragraphes (retours à la ligne) */
  int I;        /* indice d'aide */
  int DANS_MOT; /* indicateur logique: */
                /* vrai si la tête de lecture se trouve */
                /* actuellement à l'intérieur d'un mot. */

  /* Ouverture de l'ancien fichier en lecture */
  do
    {
     printf("Nom du fichier texte : ");
     scanf("%s", NOM_FICH);
     FICHIER = fopen(NOM_FICH, "r"); 
      if (!FICHIER) 
         printf("\aERREUR: Impossible d'ouvrir "
                "le fichier: %s.\n", NOM_FICH);
    }
  while (!FICHIER);
  /* Initialisations des variables */
  for (I=0; I<26; I++)
      ABC[I]=0;
   NTOT    =0;
  NAUTRES =0;
  NMOTS   =0;
  NPARA   =0;
  DANS_MOT=0;
  /* Examination des caractères du fichier */
  while (!feof(FICHIER))
     {
      C=fgetc(FICHIER);
      if (!feof(FICHIER))
         {
          /* Comptage au niveau caractères */
          if (C=='\n')
             NPARA++;
          else
             {
              NTOT++;
              if (C>='a' && C<='z')
                 ABC[C-'a']++;
              else if (C>='A' && C<='Z')
                 ABC[C-'A']++;
              else
                 NAUTRES++;
             }

          /* Comptage des mots */
          if (SEPA(C))
             {
              if (DANS_MOT)
                 {
                  NMOTS++;
                  DANS_MOT=0;
                 }
             }
          else
             DANS_MOT=1;
         }
      }
   /* Fermeture du fichier */
  fclose(FICHIER);
   /* Affichage du résultat */
  printf("Votre fichier contient :\n");
  printf("\t%d paragraphes\n", NPARA);
  printf("\t%d mots\n", NMOTS);
  printf("\t%d caractères\ndont\n", NTOT);
  for (I=0; I<26; I++)
       printf("\t%d fois la lettre %c\n", ABC[I], 'a'+I);
  printf("et %d autres caractères\n", NAUTRES);
  return 0;
} 

int SEPA(char C)
{
 /* Tableau contenant tous les séparateurs de mots */
 char SEP[12] = { '\n', ' ', ',', ';', '.', ':',
                 '?', '!', '(', ')', '"', '\'' };
 int I;

 /* Comparaison de C avec tous les éléments du tableau */
 for (I=0 ; C!=SEP[I] && I<12 ; I++) ;
 if (I==12)
     return 0;
 else
     return 1;
  /* ou bien simplement : */
 /* return (I != 12);    */
}

 Exercice 14

#include <stdio.h>
main()
{
  /* Noms des fichiers et pointeurs de référence */
  char NOM_FICH[30]; 
  FILE *FICHIER;
  /* Autres variables */
  char C;  /* caractère actuel */
  int NLIGNE, NCOLO; /* position actuelle sur l'écran */

  /* Ouverture de l'ancien fichier en lecture */
  do
    {
     printf("Nom du fichier texte : ");
     scanf("%s", NOM_FICH);
     FICHIER = fopen(NOM_FICH, "r"); 
      if (!FICHIER) 
         printf("\aERREUR: Impossible d'ouvrir "
                "le fichier: %s.\n", NOM_FICH);
    }
  while (!FICHIER)  ;
  getchar();
  /* Initialisations des variables */
  NLIGNE  = 0; NCOLO   = 0;
  /* Affichage du fichier */
  while (!feof(FICHIER))
     {
      C=fgetc(FICHIER);
      if (!feof(FICHIER))
         {
          NCOLO++;
          if (NCOLO==80 || C=='\n') /* fin de la ligne */ 
             {
              NLIGNE++;
              if (NLIGNE==25) /* fin de l'écran */ 
                 {
                  getchar();
                  NLIGNE=1;
                 }
              printf("%c",C);
              NCOLO=1;
             }
          else
             printf("%c",C);
         }
     }
   /* Fermeture du fichier */
  fclose(FICHIER);
   return 0;
}

 Exercice 15

#include <stdio.h>
#include <stdlib.h>
main()
{
  /* Prototype de la fonction CCP_TEST */
  void CCP_TEST(long COMPTE, int CONTROLE);
   /* Déclarations : */
  /* Noms des fichiers et pointeurs de référence */
  char NOM_FICH[]  = "A:\\CCP.TXT";
  FILE *FICHIER;
  /* Autres variables */
  long COMPTE;  /* nombre du compte CCP */
  int CONTROLE; /* nombre de contrôle   */

  /* Ouverture du fichier CCP.TXT en lecture */
  FICHIER = fopen(NOM_FICH, "r");
   if (!FICHIER)
     { 
      printf("\aERREUR: Impossible d'ouvrir "
             "le fichier: %s.\n", NOM_FICH);
      exit(-1);
     }

  /* Lecture des nombres et appel de la fonction CCP_TEST  */
  /* A l'aide de la chaîne de format, scanf lit les deux   */
  /* parties du nombre de CCP, les convertit en long resp. */
  /* en int et affecte les résultats aux variables COMPTE  */
  /* et CONTROLE. */
  while (!feof(FICHIER))
     {
      fscanf (FICHIER, "%ld-%d\n", &COMPTE, &CONTROLE);
      CCP_TEST(COMPTE, CONTROLE);
     }
   /* Fermeture du fichier */
  fclose(FICHIER);
   return 0;
} 

void CCP_TEST(long COMPTE, int CONTROLE)
{
 int RESTE;
 RESTE = COMPTE % 97;
 if (RESTE == 0)
     RESTE = 97;
 if (RESTE == CONTROLE)
     printf ("Le nombre CCP %ld-%d est valide\n",
 COMPTE, CONTROLE);
 else
     printf ("Le nombre CCP %ld-%d n'est pas valide\n",
 COMPTE, CONTROLE);
}

 Exercice 16

#include <stdio.h>
#include <stdlib.h>
main()
{
  /* Prototype de la fonction FUSION */
  void FUSION(int *A, int *B, int *FUS, int N, int M);
   /* Déclarations : */
  /* Noms des fichiers et pointeurs de référence */
  char FICH_A[30], FICH_B[30], FICH_FUS[30];
  FILE *FA, *FB, *FFUS;
  /* Autres variables */
  int *TABA, *TABB, *TFUS; /* pointeurs pour les tableaux */
  int LA, LB; /* Longueurs de FA et FB */
   int N; /* Nombre lu ou écrit dans un fichier */
  int I; /* Indice d'aide */

  /* Ouverture du fichier FA en lecture */
   do
    {
     printf("Nom du fichier FA : ");
     scanf("%s", FICH_A);
     FA = fopen(FICH_A, "r"); 
     if (!FA) 
         printf("\aERREUR: Impossible d'ouvrir "
                "le fichier: %s.\n", FICH_A);
    }
  while (!FA);
  /* Détection de la longueur de FA */
  for (LA=0; !feof(FA); LA++)
       fscanf(FA,"%d\n", &N);
  /* Fermeture du fichier FA */
  fclose(FA);
  /* Allocation de la mémoire pour TABA */
  TABA = malloc (LA*sizeof(int));
   if (!TABA)
       {
        printf("\a Pas assez de mémoire pour TABA\n");
        exit(-1);
       }

  /* Réouverture du fichier FA en lecture */
  FA = fopen(FICH_A, "r");
  /* Copie du contenu de FA dans TABA */
  for (I=0; I<LA; I++)
       fscanf(FA,"%d\n", TABA+I);
  /* Fermeture du fichier FA */
  fclose(FA);

  /* Mêmes opérations pour FB : */
  /* Ouverture du fichier FB en lecture */
   do
    {
     printf("Nom du fichier FB : ");
     scanf("%s", FICH_B);
     FB = fopen(FICH_B, "r");
     if (!FB) 
         printf("\aERREUR: Impossible d'ouvrir "
                "le fichier: %s.\n", FICH_B);
    }
  while (!FB);
  /* Détection de la longueur de FB */
  for (LB=0; !feof(FB); LB++)
       fscanf(FB,"%d\n", &N);
  /* Fermeture du fichier FB */
  fclose(FB);
  /* Allocation de la mémoire pour TABB */
  TABB = malloc (LB*sizeof(int));
   if (!TABB)
       {
        printf("\a Pas assez de mémoire pour TABB\n");
        exit(-1);
       }
  /* Réouverture du fichier FB en lecture */
  FB = fopen(FICH_B, "r");
  /* Copie du contenu de FB dans TABB */
  for (I=0; I<LB; I++)
       fscanf(FB,"%d\n", TABB+I);
  /* Fermeture du fichier FB */
  fclose(FB);

  /* Allocation de la mémoire pour TFUS */
   TFUS = malloc ((LA+LB)*sizeof(int));
  if (!TFUS)
       {
        printf("\a Pas assez de mémoire pour TFUS\n");
        exit(-1);
       }

  /* Fusion des tableaux TA et TB dans TFUS */
  FUSION (TABA, TABB, TFUS, LA, LB);

  /* Ouverture du fichier FFUS en écriture */
   do
    {
     printf("Nom du fichier FFUS : ");
     scanf("%s", FICH_FUS);
     FFUS = fopen(FICH_FUS, "w"); 
     if (!FFUS) 
         printf("\aERREUR: Impossible d'ouvrir "
                "le fichier: %s.\n", FICH_FUS);
    }
  while (!FFUS);
  /* Copier le contenu de TFUS dans FFUS */
  for (I=0; I<(LA+LB); I++)
       fprintf(FFUS,"%d\n", *(TFUS+I));
  /* Fermeture du fichier FFUS */
  fclose(FFUS);
   return 0;
} 

void FUSION(int *A, int *B, int *FUS, int N, int M)
{
  /* Variables locales */
 /* Indices courants dans A, B et FUS */
 int IA,IB,IFUS;  

 /* Fusion de A et B dans FUS */
 IA=0, IB=0; IFUS=0;
 while ((IA<N) && (IB<M))
    if (*(A+IA)<*(B+IB))
        {
         *(FUS+IFUS)=*(A+IA);
         IFUS++;
         IA++;
        }
    else
        {
         FUS[IFUS]=B[IB];
         IFUS++;
         IB++;
        }
 /* Si A ou B sont arrivés à la fin, alors */
 /* copier le reste de l'autre tableau.    */
 while (IA<N)
     {
      *(FUS+IFUS)=*(A+IA);
      IFUS++;
      IA++;
     }
 while (IB<M)
     {
      *(FUS+IFUS)=*(B+IB);
      IFUS++;
      IB++;
     }
}