1. while_puiss
2. while_err
3. do_while
4. for
5. jeu
6. calcul
7. moyenne
8. rotation
9. classer
10. chaînes
11. matrices
12. déterminant
13. tel
14. liste et insertion
15. agenda

1. while_puiss

#include <stdio.h>
void main(void)
 {
  int puissance=1,max;
  puts("nombre maximal désiré (ne pas dépasser 16000) ?");
  scanf("%d",&max);
  while (puissance<max) printf("%d\n",puissance*=2);
 }

2. while_err

retour au sujet de cet exercice

3. do_while

#include <stdio.h>
#include <stdlib.h> /* pour rand() */
#include <time.h>   /* pour trouver l'heure pour srand */
void main(void)
 {
  int solution,reponse,nb_essais=0;
  {time_t t;srand((unsigned) time(&t)); } /* initialiser le générateur
       à partir du compteur de temps, pour qu'il soit plus aléatoire */
  solution=rand()%11;    /* reste sera toujours entre 0 et 10 */
  do
   {
    nb_essais++;
    puts("proposez votre nombre entre 0 et 10");
    scanf("%d",&reponse);
   }
  while (reponse!=solution);
  printf("trouvé en %d essais\n",nb_essais);
 }

4. for

#include <stdio.h>
void main(void)
 {
  int i,N;
  float note,somme=0,moyenne;
  puts("nombre de notes ? ");
  scanf("%d",&N);
  for(i=0;i<N;i++)
   {
    printf("entrez votre %dième note",i+1);
    scanf("%f",&note);
    somme+=note;
   }
  moyenne=somme/N;
  printf("moyenne calculée :%5.2f\n",moyenne);
 }

5. jeu

#include <stdio.h>
#include <stdlib.h> /* pour rand() */
#include <time.h>   /* pour trouver l'heure pour srand */
void main(void)
 {
  int solution,reponse,nb_essais=0;
  { time_t t;srand((unsigned) time(&t)); } /* initialiser le générateur*/
  solution=rand()%11;     /* reste sera toujours entre 0 et 10 */
  do
   {
    nb_essais++;
    puts("proposez votre nombre entre 0 et 10");
    scanf("%d",&reponse);
    if (reponse>solution) puts("trop grand");
    else if (reponse!=solution) puts("trop petit");
   }
  while (reponse!=solution);
  printf("trouvé en %d essais\n",nb_essais);
  if (nb_essais==1) puts("vous avez eu un peu de chance");
  else if (nb_essais<4) puts("bravo");
  else if (nb_essais>6) puts("ce score me semble bien minable");
 }

6. calcul

#include <stdio.h>
void main(void)
 {
  float val1,val2,res;
  char op;
  int fin=0;
  do
   {
    puts("calcul à effectuer (par ex 5*2), ou 1=1 pour finir ? ");
    scanf("%f%c%f",&val1,&op,&val2);
    switch (op)
     {
      case '*':res=val1*val2;break;
      case '/':res=val1/val2;break;
      case '+':res=val1+val2;break;
      case '-':res=val1-val2;break;
      case '=':fin++; /* pas besoin de break, je suis déjà au } */
     }
    if (!fin) printf("%f%c%f=%f\n",val1,op,val2,res);
   }
  while (!fin);
 }

7. moyenne

#include <stdio.h>
#define max 100
typedef float tableau[max];
tableau tab;
int Nb;
void lecture(void)
 {
  int i;
  puts("entrez le nombre de notes à traiter :");
  do scanf("%d",&Nb); while ((Nb<=0)||(Nb>max));
  for(i=0;i<Nb;i++)
   {
    printf("valeur n° %d ? ",i+1);
    scanf("%f",&tab[i]);
   }
 }
float moyenne(void)
 {
  int i;
  float somme=0;
  for (i=0;i<Nb;i++) somme+=tab[i];
  return(somme/Nb);
 }
void affichage(float moy)
 {
  int i;
  printf("la moyenne des %d notes est %f\n",Nb,moy);
  for(i=0;i<Nb;i++) printf("%dième note : écart : %f\n",i+1,tab[i]-moy);
 }
void main(void)
 {
  lecture();
  affichage(moyenne());
 }

8. rotation

#include <stdio.h>
typedef int composante;
void lecture(composante *t,int *nb)
 {
  int i;
  puts("nombre de valeurs à entrer ? ");
  scanf("%d",nb);
  for(i=1;i<=*nb;i++)
   {
    printf("%dième valeur : ",i);
    scanf("%d",t++);
   }
 }
void affiche(composante *t, int max)
 {
  int i;
  for(i=0;i<max;i++) printf("%d ",*t++);
  puts(" ");
 }
void decale_bas(composante *deb, int max)
 {
  composante c,*t;
  t=deb+(max-1);
  c=*t;
  while (t>deb) {*t=*(t-1);t--;}
  *t=c;
 }
void decale_haut(composante *t, int nb)
 {
  composante c;int i;
  c=*t;
  for (i=1;i<nb;i++) {*t=*(t+1);t++;}
  *t=c;
 }
void main(void)
 {
  composante tableau[100];
  int nombre;
  lecture(tableau,&nombre);
  puts("tableau initial :");
  affiche(tableau,nombre);
  decale_haut(tableau,nombre);
  puts("décalage vers le haut :");
  affiche(tableau,nombre);
  decale_bas(tableau,nombre);
  puts("décalage vers le bas :");
  affiche(tableau,nombre);
 }

9. classer

#include <stdio.h>
#define dim 100
typedef int composante;
void lecture(composante *t,int *nb)
 {
  int i;
  puts("nombre de valeurs à entrer ? ");
  scanf("%d",nb);
  for(i=1;i<=*nb;i++)
   {
    printf("%dième valeur : ",i);
    scanf("%d",t++);
   }
 }
void affiche(composante *t, int max)
 {
  int i;
  for(i=0;i<max;i++) printf("%d ",*t++);
  puts(" ");
 }
int indice_min(composante t[],int indice_dep, int nb_indices)
/* cherche l'indice de la valeur du tableau :
 *  -soit égale à t[indice_dep], mais d'indice > à indice_dep;
 *  -soit la plus petite mais >t[indice_deb]
 */
 {
  int i,indice_resultat=-1;
  for(i=indice_dep+1;i<nb_indices;i++) if (t[i]==t[indice_dep]) return(i);
/* si on est encore là c'est qu'il n'y en pas d'égal */
  for(i=0;i<nb_indices;i++)
    if ((t[i]>t[indice_dep]) && ((indice_resultat<0) || (t[i]<t[indice_resultat]))) indice_resultat=i;
  return(indice_resultat);
}
void copier(composante *source, composante *dest, int nb)
/* copie le tableau source dans le tableau dest */
 {
  int i;
  for(i=0;i<nb;i++) *(dest++)=*(source++);
 }
void classe(composante tab[], int nb)
 {
  composante tempo[dim]; /* un malloc(sizeof(composante)*nb) aurait été
                mieux mais on n'en a pas encore parlé en cours */
  int i,ind_faits,indice;
/* 1er : recherche du plus petit, le 1er si ex aequo */
  indice=0;
  for(i=1;i<nb;i++)
   if(tab[i]<tab[indice]) indice=i;
  tempo[ind_faits=0]=tab[indice];
/* les suivants : recherche le + petit mais > au précédent */
  for(ind_faits=1;ind_faits<nb;ind_faits++)
   {
    indice=indice_min(tab,indice,nb);
    tempo[ind_faits]=tab[indice];
   }
  copier(tempo,tab,nb);
 }
void main(void)
 {
  composante tableau[dim];
  int nombre;
  lecture(tableau,&nombre);
  puts("tableau initial :");
  affiche(tableau,nombre);
  classe(tableau,nombre);
  puts("tableau classé :");
  affiche(tableau,nombre);
 }

10. chaînes

#include <stdio.h>
#define taille 255
int debut_egal(char *ch,char *sch)
/* répond si sch est exactement le début de ch */
 {
  while (*sch && *ch)
   {
    if (*sch!=*ch) return(0); else {ch++;sch++;}
   }
  return(!(*sch));
 }
void recherche(char *ch,char *sch)
 {
  int pos=0;
  while (*ch)
   {
    if (debut_egal(ch,sch)) printf("trouvé en position %d\n",pos);
    ch++;pos++;
   }
 }
void main(void)
 {
  char ch[taille],sch[taille];
  puts("chaîne à tester ? ");
  gets(ch);
  puts("sous-chaîne à trouver ?");
  gets(sch);
  recherche(ch,sch);
 }

11. matrices

#include <stdio.h>
#define DIM 10
typedef float ligne[DIM];
typedef ligne matrice[DIM];
typedef float *pointeur;

void lecture(matrice t,int *lig,int *col)
/* lit à l'écran une matrice */
 {
  int l,c;
  float f;
  puts("nombre de lignes de la matrice ?");
  scanf("%d",lig);
  puts("nombre de colonnes de la matrice ?");
  scanf("%d",col);
  for (l=0;l<*lig;l++) for(c=0;c<*col;c++)
   {
    printf("élément [%d,%d] ? ",l,c);
    scanf("%f",&f);
    t[l][c]=f;
   }
 }
void zero(float *t)
/* met toute la matrice à 0 */
 {
  int i;
  for(i=0;i<DIM*DIM;i++) *t++=0;
 }
void unit(matrice t)
/* remplit la matrice unité (1 diagonale, 0 autre) */
 {
  int i;
  zero(t);
  for(i=0;i<DIM;i++) t[i][i]=1;
 }
void init(matrice t)
/* initialisation de matrice à numlig.numcol */
 {
  int i,j;
  for(i=0;i<DIM;i++) for(j=0;j<DIM;j++) t[i][j]=i+j/10.0;
 }
void affiche(matrice t,int l,int c)
/*  puts("affichage du tableau ligne par ligne :"); */
 {
  int i,j;
  for(i=0;i<l;i++)
   {
    printf("ligne %d : ",i);
    for(j=0;j<c;j++) printf("%3.1f ",t[i][j]);
    printf("\n");
   }
 }
void produit(matrice a,matrice b,matrice c,int m,int l,int n)
/* calcul du produit */
 {
  int im,il,in;
  zero(c);
  for(im=0;im<m;im++)
    for(in=0;in<n;in++)
      for(il=0;il<l;il++)
        c[im][in]+=a[im][il]*b[il][in];
 }
void main(void)
 {
  int m,l,n,i;
  matrice a,b,c;
  lecture(a,&m,&l);
  lecture(b,&i,&n);
  if(i!=l) puts("calcul impossible : dimensions incompatibles");
  affiche(a,m,l);
  puts("--- FOIS ---");
  affiche(b,l,n);
  puts("--- FAIT ---");
  produit(a,b,c,m,l,n);
  affiche(c,m,n);
 }

12. determinant

#include <stdio.h>
#include <stdlib.h>
#define DIM 10
typedef float ligne[DIM];
typedef ligne matrice[DIM];
typedef float *pointeur;
long nb_appels;

void lecture(matrice t,int *lig)
/* lit une matrice (au clavier) */
 {
  int l,c;
  float f;
  puts("dimension de la matrice ?");
  scanf("%d",lig);
  for (l=0;l<*lig;l++) for(c=0;c<*lig;c++)
   {
    printf("élément [%d,%d] ? ",l,c);
    scanf("%f",&f);
    t[l][c]=f;
   }
 }
void zero(matrice t,int dim)
/* met toute la matrice à 0 */
 {
  int i,j;
  for(i=0;i<dim;i++)for(j=0;j<dim;j++) t[i][j]=0;
 }
void unit(matrice t, int dim)
/* remplit la matrice unité (1 diagonale, 0 autre) */
 {
  int i;
  zero(t,dim);
  for(i=0;i<dim;i++) t[i][i]=1;
 }
void affiche(matrice t,int l)
/*  puts("affichage du tableau ligne par ligne :"); */
 {
  int i,j;
  for(i=0;i<l;i++)
   {
    printf("ligne %d : ",i);
    for(j=0;j<l;j++) printf("%3.1f ",t[i][j]);
    printf("\n");
   }
 }
void copiesauflc(matrice source,matrice dest,int dim,int ligavirer)
 {
  int l,c,ld=0;
  for (l=0;l<dim;l++) if (l!=ligavirer)
   {
    for (c=1;c<dim;c++) dest[ld][c-1]=source[l][c];
    ld++;
   }
 }
float determinant(matrice m,int dim)
 {
  matrice sous_m;
  int l,signe=1;
  float det=0;
  nb_appels++;
  if (dim==1) return(m[0][0]);
  for(l=0;l<dim;l++)
   {
    copiesauflc(m,sous_m,dim,l);
    det+=signe*m[l][0]*determinant(sous_m,dim-1);
    signe=-signe;
   }
  return(det);
 }
void produit(matrice a,matrice b,matrice c,int dim)
/* calcul du produit */
 {
  int im,il,in;
  zero(c,dim);
  for(im=0;im<dim;im++)
    for(in=0;in<dim;in++)
      for(il=0;il<dim;il++)
        c[im][in]+=a[im][il]*b[il][in];
 }
void main(int argc,char *argv[])
 {
  int taille;
  matrice mat;
/*  lecture(mat,&taille);  */
      taille=atoi(argv[1]); /* test avec matrice unité, */
      unit(mat,taille);     /* au moins je connais le résultat*/
  affiche(mat,taille);
  printf("déterminant : %20.17f ",determinant(mat,taille));
  printf(" en %ld appels\n",nb_appels);
 }

13. tel

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define DIM 100
enum champs {nom,prenom,num,rue,cp,ville,tel};
char *nomchamp[7]={"Nom", "Prénom", "Numéro", "Rue",
                     "Code Postal", "Ville", "Tel"};
typedef struct 
 {
  char    nom[15];
  char    prenom[20];
  int     num;
  char    rue[60];
  long    codepostal;
  char    ville[20];
  char    tel[15];
 } fiche;

fiche *rech_nom(fiche *,char *);
fiche *rech_prenom(fiche *,char *);
fiche *rech_num(fiche *,char *);
fiche *rech_rue(fiche *,char *);
fiche *rech_cp(fiche *,char *);
fiche *rech_ville(fiche *,char *);
fiche *rech_tel(fiche *,char *);
fiche *rech_nom(fiche *,char *);

typedef fiche *ptrfiche;
typedef ptrfiche (*ptrfonction)(ptrfiche,char*);
ptrfonction tabfonction[7]={rech_nom, rech_prenom, rech_num,
                   rech_rue, rech_cp, rech_ville, rech_tel};

void affiche(fiche *f)
 {
  if(f->nom[0])
    printf("%s %s\n%d, %s\n%ld %s\nTel : %s\n", f->nom, f->prenom, 
           f->num, f->rue, f->codepostal, f->ville, f->tel);
  else
    printf("fiche inconnue\n");
 }
int idem(char *s1,char *s2)
/* compare deux chaines, dit si elles sont égales (1), ou non (0). On 
   pourrait supposer égalité quand la chaine s2 est incluse dans s1 */
 {
  return(strcmp(s1,s2)?0:1);
 }

fiche *rech_nom(fiche *pf,char *n)
 {while ((pf->nom[0])&&(!idem(pf->nom,n)))pf++;
  return(pf);}
fiche *rech_prenom(fiche *pf,char *n)
 {while ((pf->nom[0])&&(!idem(pf->prenom,n)))pf++;
  return(pf);}
fiche *rech_num(fiche *pf,char *n)
 {while ((pf->nom[0])&&(pf->num!=atoi(n)))pf++;
  return(pf);}
fiche *rech_rue(fiche *pf,char *n)
 {while ((pf->nom[0])&&(!idem(pf->rue,n)))pf++;
  return(pf);}
fiche *rech_cp(fiche *pf,char *n)
 {while ((pf->nom[0])&&(pf->codepostal!=atoi(n)))pf++;
  return(pf);}
fiche *rech_ville(fiche *pf,char *n)
 {while ((pf->nom[0])&&(!idem(pf->ville,n)))pf++;
  return(pf);}
fiche *rech_tel(fiche *pf,char *n)
 {while ((pf->nom[0])&&(!idem(pf->tel,n)))pf++;
  return(pf);}

int choix(void)
 {
  char lig[40];
  enum champs i,rep;
  for (i=nom;i<=tel;i++) printf("%d:%s ",i,nomchamp[i]);
  printf("\nou -1 pour quitter. Type de recherche désirée ? ");
  gets(lig);
  sscanf(lig,"%d",&rep);
  return(rep);
 }

void lecture(fiche *tab)
 {
  char lig[40];
  do
   {
    printf("nom (rien pour finir) ?");
    gets(tab->nom);
    if(tab->nom[0])
     {
      printf("         prénom ? ");
      gets(tab->prenom);
      printf("             N° ? ");
      gets(lig);
      sscanf(lig,"%d",&(tab->num));
      printf("            rue ? ");
      gets(tab->rue);
      printf("    code postal ? ");
      gets(lig);
      sscanf(lig,"%ld",&(tab->codepostal));
      printf("          ville ? ");
      gets(tab->ville);
      printf("n° de téléphone ? ");
      gets(tab->tel);
     }
   }
  while ((tab++)->nom[0]);
 }

void main(void)
 {
  enum champs c;
  char clef[40];
  fiche tab[DIM];
  lecture(tab);
  do
   {
    if (((c=choix())<0)||(c>6)) break;
    printf("quel(le) %s recherche-t'on ? ",nomchamp[c]);
    gets(clef);
    affiche(tabfonction[c](tab,clef));
   }
  while (c>=0);
 }

14. liste et insertion

#include <stdio.h>
#include <conio.h>
#include <ctype.h>
#include <alloc.h>

struct page {int val; struct page *suivant; };
struct page *premier;

int encore(void) /* demande si on en veut encore*/
 {
  printf("encore (O/N) ? ");
  return(toupper(getche())=='O');
 }

void lecture(void)
 {
  struct page *precedent,*nouveau;
  premier=(struct page *)malloc(sizeof(struct page));
  puts("entrez votre premier entier");
  scanf("%d",&premier->val);
  precedent=premier;
  while (encore())
   {
    nouveau=(struct page *)malloc(sizeof(struct page));
    precedent->suivant=nouveau;
    precedent=nouveau;
    puts("\nentrez votre entier");
    scanf("%d",&nouveau->val);
   }
  precedent->suivant=NULL;
 }

void affiche(struct page *debut)
 {
  printf("\nliste : ");
  while(debut!=NULL) 
   {
    printf("%d ",debut->val);
    debut=debut->suivant;
   }
  printf("\n");
 }

void suppression(void)
 {
  struct page *actu,*prec;
  actu=premier;
  while (actu!=NULL)
   {
    printf("\nvaleur : %d - supprimer celui-ci (O/N) ? ",actu->val);
    if (toupper(getche())=='O')
     {
      if(actu==premier)premier=actu->suivant;
      else prec->suivant=actu->suivant;
      free(actu);
      break;
     }
    else
     {
      prec=actu;
      actu=prec->suivant;
     }
   }
 }
void ajouter(void)
 {
  struct page *nouveau,*prec;
  printf("\najouter en premier (O/N) ? ");
  if (toupper(getche())=='O')
   {
    nouveau=(struct page *)malloc(sizeof(struct page));
    nouveau->suivant=premier;
    premier=nouveau;
    printf("\nnouvelle valeur ? ");
    scanf("%d",&(nouveau->val));
   }
  else
   {
    prec=premier;
    while(prec!=NULL)
     {
      printf("\nvaleur : %d - insérer après celui_ci (O/N) ? ", prec->val);
      if (toupper(getche())=='O')
       {
        nouveau=(struct page *)malloc(sizeof(struct page));
        nouveau->suivant=prec->suivant;
        prec->suivant=nouveau;
        printf("\nnouvelle valeur ? ");
        scanf("%d",&(nouveau->val));
        break;
       }
      else prec=prec->suivant;
     }
   }
 }

void main(void)
 {
  lecture();
  affiche(premier);
  do
   {
    suppression();
    affiche(premier);
   }
  while(encore());
  do
   {
    ajouter();
    affiche(premier);
   }
  while(encore());
 }

15. agenda

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <conio.h>

/* définitions des types et variables associées */
enum champs {nom,prenom,num,rue,cp,ville,tel};
char *nomchamp[7]={"Nom","Prénom","Numéro","Rue",
                   "Code Postal","Ville","Tel"};
typedef struct 
 {
  char    nom[15];
  char    prenom[20];
  int     num;
  char    rue[60];
  long    codepostal;
  char    ville[20];
  char    tel[15];
 } fiche;
#define taille sizeof(fiche)
typedef fiche *ptrfiche;

/* définitions des fonctions de recherche, regroupées dans un tableau */
fiche *rech_nom(fiche *,char *);
fiche *rech_prenom(fiche *,char *);
fiche *rech_num(fiche *,char *);
fiche *rech_rue(fiche *,char *);
fiche *rech_cp(fiche *,char *);
fiche *rech_ville(fiche *,char *);
fiche *rech_tel(fiche *,char *);
fiche *rech_nom(fiche *,char *);

typedef ptrfiche (*ptrfonction)(ptrfiche,char*);
ptrfonction tabfonction[7]= {rech_nom, rech_prenom, rech_num,
                    rech_rue, rech_cp, rech_ville, rech_tel};

/* variables globales */
FILE *fic;  /* fichier de données */
char *nomfic="agenda.dat";
int nb;    /* nb de fiches dans le fichier */

void init(void)
/* ouvre le fichier, détermine le nb de fiches de fic */
 {
  if ((fic=fopen(nomfic,"a+b"))==NULL)
   {
    puts("ouverture impossible du fichier de données");
    exit(1);
   }
  fseek(fic,0,2);
  nb=(int)ftell(fic)/taille;
  printf("%d fiches présentes dans l'agenda\n",nb);
 }

void ajouter(void)
 {
  char lig[40];
  fiche f;
  printf("nom             ? ");
  gets(f.nom);
  printf("         prénom ? ");
  gets(f.prenom);
  printf("         Numero ? ");
  gets(lig);
  sscanf(lig,"%d",&(f.num));
  printf("            rue ? ");
  gets(f.rue);
  printf("    code postal ? ");
  gets(lig);
  sscanf(lig,"%ld",&(f.codepostal));
  printf("          ville ? ");
  gets(f.ville);
  printf("n° de téléphone ? ");
  gets(f.tel);
  fseek(fic,0L,2);
  if(fwrite(&f,taille,1,fic)!=1)
   {
    puts("impossible d'ajouter cette fiche au fichier ");
    exit(0);
   }
  nb++;
 }

void affiche(fiche *f)
 {
  if((f!=NULL)&&(f->nom[0]))
    printf("%s %s\n%d, %s\n%ld %s\nTel : %s\n",f->nom, f-> prenom,
              f->num, f->rue,f->codepostal,f->ville,f->tel);
  else
    printf("fiche inconnue\n");
 }

int idem(char *s1,char *s2)
/* compare deux chaines, dit si elles sont égales (1), ou non (0).
   On considère égales majuscules et minuscules. 
   Une des chaines peut se terminer par *, on supposera identique 
   si tout ce qui précède l'* était identique */
 {
  for(;;)
   {
    if (((!*s1)&&(!*s2))||(*s1=='*')||(*s2=='*')) return(1);
    if ((toupper(*s1)!=toupper(*s2))||(!*s1)||(!*s2)) return(0);
    s1++;s2++;
   }
 }

fiche *rech_nom(fiche *pf,char *n)
 {
  int nblu;
  fseek(fic,0L,0);
  do 
    nblu=fread(pf,taille,1,fic);
  while ((nblu==1)&&(!idem(pf->nom,n)));
  if (nblu==1) return(pf); else return(NULL);
 }

/* les autres recherches sont à continuer */

int choix(void)
 {
  char lig[40];
  enum champs i,rep;
  for (i=nom;i<=tel;i++) printf("%d:%s ",i,nomchamp[i]);
  printf("\nou -1 pour quitter. Type de recherche désirée ? ");
  gets(lig);
  sscanf(lig,"%d",&rep);
  return(rep);
 }

void recherche(void)
 {
  enum champs c;
  char clef[40];
  fiche f;
  do
   {
    if (((c=choix())<0)||(c>6)) break;
    printf("quel(le) %s recherche-t'on ? ",nomchamp[c]);
    gets(clef);
    affiche(tabfonction[c](&f,clef));
   }
  while (c>=0);
 }

void main(void)
 {
  char rep;
  init();
  do
   {
    puts("Ajouter une fiche, Recherche d'une fiche, Quitter le prog ? ");
    switch (rep=toupper(getch()))
     {
      case 'A':ajouter();break;
      case 'R':recherche();break;
      case 'Q':fclose(fic);puts("Au revoir");break;
      default :puts("option non prévue");
     }
   }
  while (rep!='Q');
 }