COURSE CYCLISTE

******************************************************************************
******************************************************************************
				TXT2DAT
******************************************************************************
******************************************************************************
/* ---------------------------------------------------------------------------
 * Programme de conversion d'un fichier texte d'équipes en fichier binaire
 * de coureurs
 * Auteur(s)  : DESPORTES BONIN
 * Groupe TP  :1 H
 * Création   : 
 * Entrées    : un fichier texte donné sur la ligne de commande, equipes.txt 
 *              par défaut.
 *     Syntaxe du fichier :
 *  <ÉQUIPES> ::= <ÉQUIPE> +
 *  <ÉQUIPE> ::= <ABR> <NOM COMPLET DE L'ÉQUIPE>'\n'<COUREUR> +
 *  <COUREUR> ::= '\t'<DOSSARD>' '<NOM>' ''('<NATIONALITÉ>')''\n'
 *  <ABR> ::= <chaîne de 3 caractères>
 *  <NOM COMPLET DE L'ÉQUIPE> ::= <chaîne de caractères>
 *  <DOSSARD> ::= <entier>
 *  <NOM> ::= <chaîne de caractères>
 *  <NATIONALITÉ> ::= <chaîne de 3 caractères>
 * Sorties    : un fichier binaire (coureurs.dat)
 *     Le fichier binaire contient un élément par coureur sous la forme 
 *     d'un enregistrement (de taille fixe, voir la structure Coureur).
 * Avancement : 
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "temps.h"
#include "coureurs.h"

/* Nom par défaut du fichier des équipes */
#define FICHIER_EQUIPES "equipes.txt"

/* Taille maximum d'une ligne */
#define MAXLIGNE 128

/* Le caractère nul, plus facile à taper comme ça : */
#define NUL '\0'

void Usage(void);

/* ---------------------------------------------------------------------
 * Programme principal :
 *   . Pour chaque équipe du fichier d'entrée :
 *     .. récupération de l'abréviation du nom
 *     .. pour chaque coureur de l'équipe :
 *       ... construction de la structure Coureur et enregistrement 
 *           dans le fichier de sortie (et affichage).
 */
int main(int nbArgs, char *arg[])
{
  char *nomEquipes, *nomCoureurs;
  char ligne[MAXLIGNE];		/* pour lecture du fichier des équipes */
  FILE *fEquipes;
  FILE *fCoureurs;
  Coureur c;
  char Equipe[4];
  char *s;
  

  /* Analyse des arguments */
  switch (nbArgs)
   {
   case 1:		/* pas d'arguments : valeurs par défaut */
     nomEquipes = FICHIER_EQUIPES;
     nomCoureurs = FICHIER_COUREURS;
     break;
   case 2:		/* fichier des équipes fourni en argument */
     nomEquipes = arg[1];
     nomCoureurs = FICHIER_COUREURS;
     break;
   case 3:		/* fichier des équipes et fichier des coureurs
			 * fournis */
     nomEquipes = arg[1];
     nomCoureurs = arg[2];
     break;
   default:
     Usage();
   }

  printf("Création du fichier %s à partir du fichier %s\n",
	 nomCoureurs, nomEquipes);
	 
 fEquipes=fopen("equipes.txt","r");
 /*test*/
 if (fEquipes==0)
 	printf("Erreur d'ouverture du fichier");
 else
 {
 	
 fCoureurs=fopen("coureurs.dat","wb");
 /*test*/
 if (fCoureurs==0)
 	printf("Erreur d'ouverture du fichier");
 else
 {	
 printf("***************ENREGISTREMENT***************\n");
 fgets(ligne,MAXLIGNE,fEquipes);
 
 c.temps.h=0;
 c.temps.m=0;
 c.temps.s=0;
 
 while (!feof(fEquipes))
 {
  if (ligne[0]!='\t')
  {
  /*traitement pour une équipe*/
   strncpy(Equipe,ligne,3);
   Equipe[3]=NUL;
   fgets(ligne,MAXLIGNE,fEquipes);
  }
  else
  {
  /*traitement pour un coureur*/
  	/*on mémorise son dossard*/
	sscanf(ligne,"%d",&(c.dossard));
	 
	/*on mémorise le nom*/
	/*on recherche la fin du nom*/
	s=strchr(ligne,'(');
	
	/*on insère une marque NUL*/
	*(s-1)=NUL;
	strcpy(c.nom,ligne+5);
	
	/*on mémorise le pays*/
	strncpy(c.pays,s+1,3);
	c.pays[3]=NUL;
	
	/*on mémorise l'équipe*/
	strcpy(c.equipe,Equipe);
	fgets(ligne,MAXLIGNE,fEquipes);	
	affCoureur(c,stdout);
	fwrite(&c,sizeof(Coureur),1,fCoureurs);
		
   }
  }
   fclose(fCoureurs);
 printf("*****************FIN***********\n");
 afficheCoureurs("coureurs.dat",stdout);
 fclose(fEquipes);
 
 }/*test des ouvertures*/
 }	

  return EXIT_SUCCESS;

}
/*
 * Affichage du mode d'emploi et sortie du programme
 * Sorties : affichage sur la sortie erreur standard */
void Usage(void)
{
  fprintf(stderr, "Usage : \n");
  fprintf(stderr, "\ttxt2dat [[EQUIPES=equipes.txt [COUREURS=coureurs.dat]]\n");
  exit(EXIT_FAILURE);
}


******************************************************************************
******************************************************************************
				COUREURS
******************************************************************************
******************************************************************************
/* ---------------------------------------------------------------------------
 * Module de gestion des coureurs.
 * Auteur(s)  :DESPORTES BONIN 
 * Groupe TP  :1 H
 * Création   : 
 * Avancement : TERMINE
 */

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include "temps.h"

#define COUREURS_C
#include "coureurs.h"

/* Affichage d'un coureur sur un fichier texte
 * Entrées : un coureur, out : fichier texte supposé ouvert en écriture
 * Sorties : écriture du coureur sur out
 * Exemple d'utilisation : (affichage sur l'écran)
 *   affCoureur(c, stdout); */
void affCoureur(Coureur c, FILE *out)
{
  fprintf(out,"%d %s %s %s ",c.dossard,c.nom,c.equipe,c.pays);
  affTemps(c.temps,out);
   fprintf(out,"\n");

}

/* Affichage d'un fichier de coureurs sur un fichier texte
 * Entrées : nomCoureurs, fichier binaire de coureurs ;
 *           out : fichier texte supposé ouvert en écriture
 * Sorties : écriture du contenu de nomCoureurs sur out
 * Exemple d'utilisation : (affichage sur l'écran)
 *   afficheCoureurs("coureurs.dat", stdout); */
void afficheCoureurs(char nomCoureurs[], FILE *out)
{
  FILE* Fc;
  Coureur c;
  
  Fc=fopen(nomCoureurs,"rb");
  /*A TEST*/
  if (Fc==0)
 	printf("Erreur d'ouverture du fichier");
  else
  {
  /*lecture*/
   fread(&c,sizeof(Coureur),1,Fc);
   while (!feof(Fc))
   {
   	fprintf(out,"%d %s %s %s  ",c.dossard,c.nom,c.equipe,c.pays);
	affTemps(c.temps,out);
	fprintf(out,"\n");
   	fread(&c,sizeof(Coureur),1,Fc);
   }
   fclose(Fc);
  }
}

/* Recherche d'un coureur dans un fichier binaire de coureurs
 * Entrées : le numéro de dossard du coureur ;
 *           coureurs : fichier binaire supposé ouvert en lecture ;
 * Sorties : rang du coureur dans le fichier ou -1 s'il n'existe pas */
int chercheCoureur(int dossard, FILE *coureurs)
{
  int rang=0;
  Coureur c;
 
  
  /*on se positionne au début*/
  fseek(coureurs,0,SEEK_SET);
  fread(&c,sizeof(Coureur),1,coureurs);
   while (!feof(coureurs))
   {
    if (c.dossard==dossard)
     break;
    else
    {	
	fread(&c,sizeof(Coureur),1,coureurs);
	rang++;
    }
   }
  if (feof(coureurs))
  	return -1;
  else  return rang;
}


******************************************************************************
******************************************************************************
				TRI
******************************************************************************
******************************************************************************
/* ---------------------------------------------------------------------------
 * Programme de tri d'un fichier de coureurs selon le numéro de dossard, tri
 * par insertion en chargeant le fichier dans une table. La taille maximum
 * de la table est fixée par constante.
 * Auteur(s)  : 
 * Groupe TP  :
 * Création   : 
 * Entrées    : le fichier de coureurs donné sur la ligne de commande, défaut
 *              coureurs.dat (voir module coureurs).
 * Sorties    : le même fichier trié.
 * Avancement : 
 */

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include "temps.h"
#include "coureurs.h"

void Usage(void);

/* ---------------------------------------------------------------------
 * Programme principal :
 *   . Chargement du fichier à trier dans un table avec insertion dans
 *     l'ordre du numéro de dossard.
 *   . Réécriture du fichier trié sur disque
 */
int main(int nbArgs, char *arg[])
{
  char *nomCoureurs;
  int j,nbcoureur;
  FILE* Fc;
  Coureur c;
  Coureur T[200];
  
  switch (nbArgs)
  {
    case 1: /* pas d'arguments */
      nomCoureurs = FICHIER_COUREURS;
      break;
    case 2: /* fichier des coureurs fourni en argument */
      nomCoureurs = arg[1];
      break;
    default:
      Usage();
  }
   
 c.temps.h=0;
 c.temps.m=0;
 c.temps.s=0;
 
  /* chargement du fichier dans la table avec insertion à la volée */
  Fc=fopen(nomCoureurs,"rb");
  /*test*/
  if (Fc==0)
 	printf("Erreur d'ouverture du fichier");
 else
 {
  fread(&c,sizeof(Coureur),1,Fc);
  j=0;nbcoureur=0;
  while (!feof(Fc))
  {
  /*selon les differents cas*/
  /*le tableau est vide*/
 	if (nbcoureur==0)
	{ 
	T[0]=c;nbcoureur++;
	}
	/*le tableau contient au moins un élément*/
  	else
	{ 
		/*insertion en fin de tableau*/
		if (T[nbcoureur-1].dossard < c.dossard)
  		{	T[nbcoureur]= c;nbcoureur++;
		}
			
		/*insertion avec décalage*/
		else
		{
			j=nbcoureur-1;
			while ((j>=0) && (T[j].dossard > c.dossard))
			{
				T[j+1]=T[j];
				j--;
			}
		T[j+1]=c;
		nbcoureur++;
  		}
	}
	fread(&c,sizeof(Coureur),1,Fc);
  }
 fclose(Fc);
 
 	
Fc=fopen(nomCoureurs,"wb");
  /*a tester*/
  
  /* Réécriture de la table dans le fichier */
  for(j=0;j<nbcoureur;j++)
   	fwrite(&T[j],sizeof(Coureur),1,Fc);
	
fclose(Fc);

Fc=fopen(nomCoureurs,"rb");	
  /* Réaffichage pour trace */
  afficheCoureurs("coureurs.dat",stdout);
  
fclose(Fc);	
 }  
  return EXIT_SUCCESS;
}

/*
 * Affichage du mode d'emploi et sortie du programme
 * Sorties : affichage sur la sortie erreur standard */
void Usage(void)
{
  fprintf(stderr, "Usage : \n");
  fprintf(stderr, "\ttri [COUREURS=coureurs.dat]\n");
  exit(EXIT_FAILURE);
}


******************************************************************************
******************************************************************************
				TEMPS
******************************************************************************
******************************************************************************
/* ---------------------------------------------------------------------------
 * Module de gestion du temps en heure, minutes, secondes.
 * Auteur(s)  : Damien Genthial
 * Création   : 10 juillet 2000
 */

#include <stdio.h>
#include <time.h>

#define TEMPS_C
#include "temps.h"

/* Affichage d'un temps sur un fichier texte
 * Entrées : un temps t, out : fichier texte supposé ouvert en écriture
 * Sorties : écriture du temps sur out
 * Exemple d'utilisation : (affichage sur l'écran)
 *   affTemps(t, stdout); */
void affTemps(Temps t, FILE *out)
{
   fprintf(out, "%02d:%02d:%02d", t.h, t.m, t.s);
}

/* Addition des deux temps t1 et t2 */
Temps addTemps(Temps t1, Temps t2)
{
  Temps res = {0, 0, 0};

  res.s = t1.s + t2.s;
  if (res.s >= 60)
  {
    res.s = res.s - 60;
    res.m = 1;
  }
  res.m = res.m + t1.m + t2.m;
  if (res.m >= 60)
  {
    res.m = res.m - 60;
    res.h = 1;
  }
  res.h = res.h + t1.h + t2.h;

  return res;
}

/* Différence gd - pt (on suppose gd >= pt) */
Temps diffTemps(Temps gd, Temps pt)
{
  Temps res = {0, 0, 0};

  res.s = gd.s - pt.s;
  if (res.s < 0)
  {
    res.s = res.s + 60;
    res.m = -1;
  }
  res.m = res.m + gd.m - pt.m;
  if (res.m < 0)
  {
    res.m = res.m + 60;
    res.h = -1;
  }
  res.h = res.h + gd.h - pt.h;

  return res;
}

/* Comparaison de deux temps, retourne -1 si t1 < t2, 0 si t1 = t2 et 
 * 1 si t1 > t2 */
int compareTemps(Temps t1, Temps t2)
{
  if (t1.h < t2.h)
    return -1;

  if (t1.h > t2.h)
    return 1;

  if (t1.m < t2.m)
    return -1;

  if (t1.m > t2.m)
    return 1;

  if (t1.s < t2.s)
    return -1;

  if (t1.s > t2.s)
    return 1;

  return 0;
}


/* Retourne l'heure système */
Temps Heure(void)
{
  struct tm *temps;
  time_t timer;
  Temps res;

  timer = time(NULL);
  temps = localtime(&timer);
  res.h = temps->tm_hour;
  res.m = temps->tm_min;
  res.s = temps->tm_sec;

  return res;
}


******************************************************************************
******************************************************************************
				BONIFICATION
******************************************************************************
******************************************************************************
/* ---------------------------------------------------------------------------
 * Programme de bonification (on enlève un temps donné au temps d'un coureur)
 * Auteur(s)  : DESPORTES BONIN
 * Groupe TP  :1 H
 * Création   : 
 * Entrées    : le fichier des coureurs (coureurs.dat par défaut)
 *		une liste de numéros de coureur et la bonification associée,
 *		terminée par le numéro 0 
 * Sorties    : le fichier des coureurs mis à jour,
 *		des traces à l'écran.
 * Avancement : 
 */

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include "temps.h" 
#include "coureurs.h"

void Usage(void);

/* ---------------------------------------------------------------------
 * Programme principal :
 *   . Pour chaque numéro de coureur lu au clavier :
 *     .. recherche du rang dans le fichier
 *     .. saisie de la bonification (nombre de secondes)
 *     .. affichage de la valeur avant bonification et de valeur après
 *        bonification
 *     .. mise à jour du fichier
 */
int main(int nbArgs, char *arg[])
{
  char *nomCoureurs;
  FILE *fCoureurs;
  int n, rang;
  Temps bonif;
  Coureur c;
  char *r;
  
  switch (nbArgs)
  {
    case 1: /* pas d'arguments, valeur par défaut (voir coureurs.h) */
      nomCoureurs = FICHIER_COUREURS;
      break;
    case 2: /* fichier des coureurs fourni en argument */
      nomCoureurs = arg[1];
      break;
    default:
      Usage();
  }
  fCoureurs=fopen(nomCoureurs,"rw+b");
  
  if (fCoureurs==0)
 	printf("Erreur d'ouverture du fichier");
 else
 {
  
  /*saisie controlée*/
  while (1)
  {
  	printf("***************\nEntrez un numéro de dossard (0 pour STOP):");
	scanf("%d",&n);
	
	if (n==0)
	 break;
	else
	{
	 printf("\n");
	 rang=chercheCoureur(n,fCoureurs);
	 /*pour etre sure d'etre au debut -->*/
	 fseek(fCoureurs,0,SEEK_SET);
	if (rang != -1)
	{
		/*deplacement de la taille de la structure*/
		fseek(fCoureurs,rang*sizeof(Coureur),SEEK_SET);
		/*mise en mémoire du coureur*/
		fread(&c,sizeof(Coureur),1,fCoureurs);
		/*vérification visuel pour l utilisateur*/
		printf("DOSSARD [%d] TEMPS:",c.dossard);
		affTemps(c.temps,stdout);
		
		fseek(fCoureurs,-1*sizeof(Coureur),SEEK_CUR);
	bonif.h=0;
	bonif.m=0;
		printf("\nENTRZ LA BONIFICATION : ");
		scanf("%d",&(bonif.s));
		
		c.temps=diffTemps(c.temps, bonif);
		printf("nouveau temps :");
		affTemps(c.temps,stdout);
		printf("\n");
		fwrite(&c,sizeof(Coureur),1,fCoureurs);
	affCoureur(c,stdout);	
	}
	/*AIDE A LA SAISIE DU DOSSARD*/
	else
	{	printf("Vérifier le numéro de dossard!! Voulez vous voir la liste ?(o/n)");
		scanf("%s",r);
		printf("\n*********\n");
		if ((*r=='o') || (*r=='O'))
		  afficheCoureurs(nomCoureurs,stdout);	
	}
	}
}	
 	fclose(fCoureurs);
	
 }
	
	
	

  return EXIT_SUCCESS;
}

/*
 * Affichage du mode d'emploi et sortie du programme
 * Sorties : affichage sur la sortie erreur standard */
void Usage(void)
{
  fprintf(stderr, "Usage : \n");
  fprintf(stderr, "\ttri [COUREURS=coureurs.dat]\n");
  exit(EXIT_FAILURE);
}


******************************************************************************
******************************************************************************
				MAKEFILE
******************************************************************************
******************************************************************************
#Makefile pour les programmes du stage C
#Auteurs : 
#Groupe TP : 
 
#Pour compiler les modules
CC=cc -g -ansi -c -Wall
txt2dat: txt2dat.o coureurs.o temps.o
	cc -g -o txt2dat txt2dat.o coureurs.o temps.o -Wall
 
#Module Principale
txt2dat.o: txt2dat.c coureurs.h temps.h
	$(CC) txt2dat.c
	
#Module tri
tri: tri.o coureurs.o temps.o
	cc -g -o tri tri.o coureurs.o temps.o -Wall
	
tri.o: tri.c coureurs.h temps.h
	$(CC) tri.c

#Module bonification
bonification: bonification.o coureurs.o temps.o
	cc -g -o bonification bonification.o coureurs.o temps.o -Wall
	
bonification.o: bonification.c coureurs.h temps.h
	$(CC) bonification.c
	
#Module coureurs
coureurs.o: coureurs.c coureurs.h temps.h
	$(CC) coureurs.c

#Module temps
temps.o: temps.c temps.h
	$(CC) temps.c

#Pour faire le ménage
clean:
	rm -f *.o txt2dat bonification tri
#Pour faire le compte rendu
cptrd:
	@cat txt2dat.c > CR_TP
	@echo -e "\f" >> CR_TP
	@cat coureurs.c >> CR_TP
	@echo -e "\f" >> CR_TP
	@cat tri.c >> CR_TP
	@echo -e "\f" >> CR_TP
	@cat temps.c >> CR_TP
	@echo -e "\f" >> CR_TP
	@cat bonification.c >> CR_TP
	@echo -e "\f" >> CR_TP
	@echo -e "MAKEFILE\n" >> CR_TP
	@cat Makefile >> CR_TP
	@echo -e "\f" >> CR_TP
	@echo -e "TRACE" >> CR_TP
	@echo -e "TXT2DAT\n" >> CR_TP
	@txt2dat >> CR_TP
	@echo -e "\f" >> CR_TP
	@echo -e "TRI" >> CR_TP
	@tri >> CR_TP
	@random >> CR_TP
	@echo -e "\f" >> CR_TP
	@bonification<test>test.txt >> CR_TP
	
#Pour ouvrir tout les programmes en arrière plan
open:
	nedit txt2dat.c & 
	nedit coureurs.h & 
	nedit temps.h & 
	nedit coureurs.c & 
	nedit temps.c & 
	nedit bonification.c & 
	nedit tri.c &



TRACE
TXT2DAT

Création du fichier coureurs.dat à partir du fichier equipes.txt
***************ENREGISTREMENT***************
151 BROCHARD Laurent A2R FRA 00:00:00
152 ASTARLOZA Mikel A2R ESP 00:00:00
153 BOTCHAROV Alexandre A2R RUS 00:00:00
154 CHAURREAU Inigo A2R ESP 00:00:00
155 FLICKINGER Andy A2R FRA 00:00:00
156 KIRSIPUU Jaan A2R EST 00:00:00
157 ORIOL Christophe A2R FRA 00:00:00
158 PORTAL Nicolas A2R FRA 00:00:00
159 TURPIN Ludovic A2R FRA 00:00:00
201 DUFAUX Laurent ALS SUI 00:00:00
202 BALDATO Fabio ALS ITA 00:00:00
203 BERTOLINI Alessandro ALS ITA 00:00:00
		...........
5 HINCAPIE George USP USA 00:00:00
6 LANDIS Floyd USP USA 00:00:00
7 PADRNOS Pavel USP CZE 00:00:00
8 PENA Victor-Hugo USP COL 00:00:00
9 RUBIERA José-Luis USP ESP 00:00:00
*****************FIN***********
151 BROCHARD Laurent A2R FRA  00:00:00
152 ASTARLOZA Mikel A2R ESP  00:00:00
153 BOTCHAROV Alexandre A2R RUS  00:00:00
154 CHAURREAU Inigo A2R ESP  00:00:00
155 FLICKINGER Andy A2R FRA  00:00:00
		...........
26 KLÖDEN Andréas TEL GER  00:00:00
27 NARDELLO Daniele TEL ITA  00:00:00
28 VINOKOUROV Alexandre TEL KAZ  00:00:00
29 ZABEL Erik TEL GER  00:00:00
1 ARMSTRONG Lance USP USA  00:00:00
2 HERAS Roberto USP ESP  00:00:00
3 BELTRAN Manuel USP ESP  00:00:00
4 EKIMOV Vjatceslav USP RUS  00:00:00
5 HINCAPIE George USP USA  00:00:00
6 LANDIS Floyd USP USA  00:00:00
7 PADRNOS Pavel USP CZE  00:00:00
8 PENA Victor-Hugo USP COL  00:00:00
9 RUBIERA José-Luis USP ESP  00:00:00


TRI
1 ARMSTRONG Lance USP USA  00:00:00
2 HERAS Roberto USP ESP  00:00:00
3 BELTRAN Manuel USP ESP  00:00:00
4 EKIMOV Vjatceslav USP RUS  00:00:00
5 HINCAPIE George USP USA  00:00:00
6 LANDIS Floyd USP USA  00:00:00
7 PADRNOS Pavel USP CZE  00:00:00
8 PENA Victor-Hugo USP COL  00:00:00
9 RUBIERA José-Luis USP ESP  00:00:00
11 BELOKI Joseba ONE ESP  00:00:00
12 ANDRLE René ONE CZE  00:00:00
13 AZEVEDO José ONE POR  00:00:00
14 GONZALEZ-GALDEANO Alvaro ONE ESP  00:00:00
		..............
214 EDALEINE Christophe DEL FRA  00:00:00
215 FINOT Frédéric DEL FRA  00:00:00
216 GOUBERT Stephane DEL FRA  00:00:00
217 KRIVTSOV Yuriy DEL UKR  00:00:00
218 LEFEVRE Laurent DEL FRA  00:00:00
219 NAZON Jean-Patrick DEL FRA  00:00:00


(  1) ARMSTRONG Lance                          (USP, USA) : 05:46:43
(  2) HERAS Roberto                            (USP, ESP) : 05:55:57
(  3) BELTRAN Manuel                           (USP, ESP) : 05:55:53
(  4) EKIMOV Vjatceslav                        (USP, RUS) : 05:12:46
(  5) HINCAPIE George                          (USP, USA) : 05:01:09
(  6) LANDIS Floyd                             (USP, USA) : 05:07:02
(  7) PADRNOS Pavel                            (USP, CZE) : 05:19:50
(  8) PENA Victor-Hugo                         (USP, COL) : 05:46:23
(  9) RUBIERA José-Luis                        (USP, ESP) : 05:06:00
( 11) BELOKI Joseba                            (ONE, ESP) : 05:16:52
( 12) ANDRLE René                              (ONE, CZE) : 05:08:11
		..............
(207) MIHOLJEVIC Vladimir                      (ALS, CRO) : 05:55:12
(208) NOE Andrea                               (ALS, ITA) : 05:04:14
(209) PELLIZOTTI Franco                        (ALS, ITA) : 05:29:59
(211) HALGAND Patrice                          (DEL, FRA) : 05:56:33
(212) BOURQUENOUD Pierre                       (DEL, SUI) : 05:55:30
(213) DUMOULIN Samuel                          (DEL, FRA) : 05:22:40
(214) EDALEINE Christophe                      (DEL, FRA) : 05:04:59
(215) FINOT Frédéric                           (DEL, FRA) : 05:25:13
(216) GOUBERT Stephane                         (DEL, FRA) : 05:07:41
(217) KRIVTSOV Yuriy                           (DEL, UKR) : 05:13:44
(218) LEFEVRE Laurent                          (DEL, FRA) : 05:14:01
(219) NAZON Jean-Patrick                       (DEL, FRA) : 05:39:06


***************
Entrez un numéro de dossard (0 pour STOP):
DOSSARD [1] TEMPS:05:46:43
ENTRZ LA BONIFICATION : nouveau temps :05:45:43
1 ARMSTRONG Lance USP USA 05:45:43
***************
Entrez un numéro de dossard (0 pour STOP):
DOSSARD [2] TEMPS:05:55:57
ENTRZ LA BONIFICATION : nouveau temps :05:55:27
2 HERAS Roberto USP ESP 05:55:27
***************
Entrez un numéro de dossard (0 pour STOP):

• INITIATION AUX TUBES UNIX (PIPE())
• RÉALISATION D'UN SERVEUR ECHO TCP MULTICLIENT (UNIX)

• CALCULATEUR D'IMC EN CONSOLE
• GESTION D'UNE MÉDIATHÈQUE
• RESISTANCE EQUIVALANTE DE RESISTANCES EN SERIE OU PARALLELE
• CALCUL DE RESISTANCE EQUIVALANTE DE PLUSIEURS RESISTANCES EN SERIE OU PARALLELE
• CODES LINÉAIRES