Course cycliste

Soyez le premier à donner votre avis sur cette source.

Snippet vu 7 481 fois - Téléchargée 30 fois

Contenu du snippet

gestion du tour de france

Source / Exemple :

******************************************************************************
******************************************************************************
				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):

Conclusion :

amusez vous

A voir également

Ajouter un commentaire Commentaires
cs_djl
Messages postés
3011
Date d'inscription
jeudi 26 septembre 2002
Statut
Membre
Dernière intervention
27 novembre 2004
8
14 nov. 2003 à 20:24
mr.x ==> tous les fichiers du projet sont la, ils sont separés par des lignes d'etoiles
cs_Mr.X
Messages postés
118
Date d'inscription
mercredi 22 octobre 2003
Statut
Membre
Dernière intervention
2 novembre 2007

14 nov. 2003 à 18:50
T'a oublier le zip ondirait, ou tu trouve coureurs.h.
E tous cas moi, je ne le vois pas.

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.