INSA/c
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Lecture des coureurs via un fichier, ajout de commentaires

Browse source
This commit is contained in:
Yohan Boujon 2022-11-26 15:12:00 +01:00
parent 9563412ad7
commit cfd9e3cb7b
3 changed files with 229 additions and 65 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
header/readfile.h
View file

@ -4,4 +4,7 @@
#include <stdbool.h>
int getNbLines(FILE * readFile);
char * getLines(FILE * readFile,int nbLines);
int getFileSize(FILE * readFile);
void getStringFromFile(FILE * readFile,int nbLines,char * returnString,int * size);
char * getLine(char * string,int line);
void string2Coureur(char * string,int nbLines);

220
src/liste.c
View file

@ -3,12 +3,23 @@
int main(void)
{
int size;
FILE * f=fopen ("fichier_coureurs.txt","r");
//printf("Number of lines : %d\n",getNbLines(f));
getLines(f,getNbLines(f));
char * fileString = (char *)(malloc(getFileSize(f)*sizeof(char)));
int fileLines = getNbLines(f);
getStringFromFile(f,fileLines,fileString,&size);
int stepsNb = atoi(getLine(fileString,1));
int teamsNb = atoi(getLine(fileString,2));
printf("Nombre d'etapes : %d\t Nombre d'equipes :%d\n",stepsNb,teamsNb);
string2Coureur(fileString,fileLines);
return 0;
}
/**
* @brief initialise un element en memoire qui encapsule une strucure de coureur au champs vide
*
* @return returnElement retourne un element vierge
*/
struct element * initElement(void)
{
struct element * returnElement = (struct element *)malloc(sizeof(struct element));
@ -17,6 +28,12 @@ struct element * initElement(void)
return returnElement;
}
/**
* @brief initialise chaque element de la liste a partir de initElement
*
*
* @return l
*/
liste initListe(void)
{
liste l;
@ -69,24 +86,42 @@ void printlist(liste l)
printf("NULL \n");
}
void allerDebut(liste * l)// car demandee dans le TP zero reference
/**
* @brief Mettre le poiteur courant d'une liste sur le premiere element
*
* @param l liste ou l'on modifie le poiteur courant
*/
void allerDebut(liste * l)
{
l->courant = l->debut;
}
void allerFin(liste * l)// car demandee dans le TP zero reference
/**
* @brief Mettre le poiteur courant d'une liste sur le derniee element
*
* @param l liste ou l'on modifie le poiteur courant
*/
void allerFin(liste * l)
{
l->courant = l->fin;
}
void avancer(liste * l) // car demandee dans le TP zero reference
/**
* @brief Mettre le poiteur courant sur l'element suivant
*
* @param l liste ou l'on modifie le poiteur courant
*/
void avancer(liste * l)
{
l->courant = l->courant->suiv;
}
coureur * coureurCourant(liste * l)// car demandee dans le TP zero reference
/**
* @brief Retourne le coureur encapsulee dans l'element pointer par le pointeur courant
*
* @param l liste ou l'on modifie le poiteur courant
*/
coureur * coureurCourant(liste * l)
{
return l->courant->coureurActuel;
}
@ -97,95 +132,160 @@ coureur * coureurCourant(liste * l)// car demandee dans le TP zero reference
* fonctionnement :
-declaration d'un poiteur eParcours egale l'adresse du premiere element (variable temporaire)
-declaration d'un poiteur(ePrevious) qui stockera temporairement l'adresse des elements pendant la reconstruction du chainage
-
* @param listeActuel
* @param coureurSuppr
-si l'element a supprimer est le premiere element de la liste :
-le poiteur courant pointe sur l'element suivant
-le poiteur pointant sur le premiere element poite sur le deuxieme
-si l'element a suppr n'est pas le deuxieme :
-ePrevious egale l'adresse du premiere element
-eParcours egale l'adresse du deuxieme element
-tant que l'element poitee par eParcours ne contient pas le courreur a supprimer faire :
-ePrevious pointe sur l'element suivant
-eParcours pointe sur l'element suivant
-l'element avant celui a suprimer pointe sur l'element sur le qu'elle poite l'element a supprimer
-supression de l'element
* @param listeActuel Liste ou l'on suppr un element
* @param coureurSuppr le coureur qui doit etre dans l'element pour le supprimer
*/
void effacerCoureur(liste * listeActuel,coureur * coureurSuppr)
{
struct element *eParcours =listeActuel->debut;
struct element * ePrevious;
if(eParcours->coureurActuel == coureurSuppr) //si l'element a supprimer est le premiere element de la liste :
if(eParcours->coureurActuel == coureurSuppr)
{
listeActuel->courant=eParcours->suiv; //le poiteur courant pointe sur l'element suivant
listeActuel->debut=eParcours->suiv; //le poiteur pointant sur le premiere element poite sur le deuxieme
listeActuel->courant=eParcours->suiv;
listeActuel->debut=eParcours->suiv;
}
else{ //si l'element a suppr n'est pas le deuxieme
ePrevious=eParcours; //ePrevious egale l'adresse du premiere element
eParcours=eParcours->suiv; //eParcours egale l'adresse du deuxieme element
while(eParcours->coureurActuel != coureurSuppr){ //tant que l'element poitee par eParcours ne contient pas le courreur a supprimer faire :
ePrevious=ePrevious->suiv; //ePrevious pointe sur l'element suivant
eParcours=eParcours->suiv; //eParcours pointe sur l'element suivant
else{
ePrevious=eParcours;
eParcours=eParcours->suiv;
while(eParcours->coureurActuel != coureurSuppr){
ePrevious=ePrevious->suiv;
eParcours=eParcours->suiv;
}
ePrevious->suiv=eParcours->suiv; //l'element avant celui a suprimer pointe sur l'element sur le qu'elle poite l'element a supprimer
free(eParcours); //supression de l'element
ePrevious->suiv=eParcours->suiv;
free(eParcours);
}
}
/**
* @brief Renvoie le nombre d'elements d'une liste
fonctionnement :
-initilisation a 0 d'un compteur (int)
-decleration d'un poiteur elementActuel initialisee au poiteur debut present dans liste qui pointe sur le premier element du chainage
-tant que elementActuel n'est pas egale a l'adresse du derniere element faire
-increment compteur
-elementActuel pointe sur l'element suivant
-retourne le compteur
*
* @param l l la liste dont on ve connaitre la taille
* @return int le nombre d'element (on compte a partir de 0)
*/
int tailleListe(liste l)
{
int returnValue=0; //initilisation a 0 d'un compteur (int)
struct element * elementActuel = l.debut; //decleration d'un poiteur elementActuel initialisee au poiteur debut present dans liste qui pointe sur le premier element du chainage
while(elementActuel->suiv != l.fin->suiv) //tant que elementActuel n'est pas egale a l'adresse du derniere element faire :
int returnValue=0;
struct element * elementActuel = l.debut;
while(elementActuel->suiv != l.fin->suiv)
{
returnValue++; //increment compteur
elementActuel=elementActuel->suiv; //elementActuel pointe sur l'element suivant
returnValue++;
elementActuel=elementActuel->suiv;
};
return returnValue; //retourne le compteur
return returnValue;
}
/**
* @brief retourne le courreur contenue dans l'element nb d'une liste (on considere un element 0)
* fonctionnement :
-init elementCourant a l'adresse du premiere element de la liste
-pour i allant de 0 a nb-1
-a la fin de la boucle elementcourant pointe sur l'element nb (on considere un element 0)
-renvoie le coureur encapsulee dans l'element nb
* @param l la liste ou doit se trouver l'element encapsulant le coureur
* @param nb le numero d'element rechercher
* @return coureur*
*/
coureur * getCoureur(liste l,int nb)
{
struct element * elementCourant = l.debut; //init elementCourant a l'adresse du premiere element de la liste
struct element * elementCourant = l.debut;
for(int i=0;i<nb;i++)
{
elementCourant=elementCourant->suiv; //a la fin de la boucle elementcourant pointe sur l'element nb (on considere un element 0)
elementCourant=elementCourant->suiv;
}
return elementCourant->coureurActuel; //renvoie le coureur encapsulee dans l'element nb
return elementCourant->coureurActuel;
}
/**
* @brief inverse l'element nb et nb+1 dans une liste (on considere un element 0)
* fonctionnement :
-decleration d'un poiteur elementCourant initialisee au poiteur debut present dans liste qui pointe sur le premier element du chainage
-declaration et allocation en memoire(a l'adresse *elemeentPrecedent) d'une taille de structure element de type element
-pour i allant de 0 a nb-1 faire :
-en fin de boucle elementCourant poite sur l'element nb et elementPrecendent nb-1
-declaration de elementsuivant qui poite sur l'element nb+1
-elementCourant pointe sur nb+1
-elementSuivant pointe sur nb
-si l'element a intervertir est le premier :
-le poiteur courant pointe sur l'ancien deuxieme element
-le poiteur debut pointe sur l'ancien deuxieme
-si l'element a intervertir diff du premier :
-element nb-1 pointe sur element nb
-le poiteur courant pointe sur le premier element
* @param l liste ou l'on inverse les elements
* @param nb le numero d'element inverser avec nb+1
*/
void invertCoureur(liste * l,int nb)
{
struct element * elementDebut = l->debut; //decleration d'un poiteur elementCourant initialisee au poiteur debut present dans liste qui pointe sur le premier element du chainage
struct element * elementPrecedent = (struct element *)(malloc(sizeof(struct element)));//declaration et allocation en memoire(a l'adresse *elemeentPrecedent) d'une taille de structure element de type element
for(int i=0;i<nb;i++) //pour i allant de 0 a nb-1
struct element * elementDebut = l->debut;
struct element * elementPrecedent = (struct element *)(malloc(sizeof(struct element)));
for(int i=0;i<nb;i++)
{
elementPrecedent = elementDebut; //en fin de boucle elementCourant poite sur l'element nb et elementPrecendent nb-1
elementPrecedent = elementDebut;
elementDebut=elementDebut->suiv;
}
struct element * elementSuivant = elementDebut->suiv; //declaration de elementsuivant qui poite sur l'element nb+1
elementDebut->suiv=elementSuivant->suiv; //elementCourant pointe sur nb+1
elementSuivant->suiv=elementDebut; //elementSuivant pointe sur nb
if(nb==0) //si l'element a intervertir est le premier :
struct element * elementSuivant = elementDebut->suiv;
elementDebut->suiv=elementSuivant->suiv;
elementSuivant->suiv=elementDebut;
if(nb==0)
{
l->courant=elementSuivant; //le poiteur courant pointe sur l'ancien deuxieme element
l->debut=l->courant; //le poiteur debut pointe sur l'ancien deuxieme
l->courant=elementSuivant;
l->debut=l->courant;
}
else{ //si l'element a intervertir diff du premier :
elementPrecedent->suiv = elementSuivant; //element nb-1 pointe sur element nb
l->courant=l->debut; //le poiteur courant pointe sur le premier element
else{
elementPrecedent->suiv = elementSuivant;
l->courant=l->debut;
}
}
void triListe(liste * l,int taille)
/**
* @brief trie bulle des element d'une liste a partir du temps contenue dans la structure encapsule dans l'element
* fonctionnement :
-pour i allant du nombre d'element dans la liste a 2 step -1
-pour j allant de 0 a i-1 step 1
-si leCourreur taille -i a un temps < au coureur taille-i+1
-inverser les courreurs j et j+1
* @param l liste a trier
* @param taille represente la taille de la liste
*/
void triListe(liste * l,int taille)
{
bool tabOrdered = true;
for(int i=taille-1;i>1;i--)
{
bool tabOrdered = true;
for(int i=taille-1;i>1;i--) //pour i allant du nombre d'element dans la liste a 2 step -1
for(int j=0;j<=i-1;j++)
{
for(int j=0;j<=i-1;j++) //pour j allant de 0 a i-1 step 1
if(getCoureur(*l,j+1)->temps < getCoureur(*l,j)->temps)
{
if(getCoureur(*l,j+1)->temps < getCoureur(*l,j)->temps)//si leCourreur taille -i a un temps < au coureur taille-i+1
{
invertCoureur(l,j); //inverser les courreurs
tabOrdered = false;
}
//printlist(*l);
}
if(tabOrdered)
{
return;
invertCoureur(l,j);
tabOrdered = false;
}
printlist(*l);
}
if(tabOrdered)
{
return;
}
}
}

69
src/readfile.c
View file

@ -1,4 +1,5 @@
#include "../header/readfile.h"
#define MAXLINE 50
int getNbLines(FILE * readFile)
{
@ -13,14 +14,74 @@ int getNbLines(FILE * readFile)
return count+1;
}
char * getLines(FILE * readFile,int nbLines)
void getStringFromFile(FILE * readFile,int nbLines,char * returnString,int * size)
{
int i;
char str[100];
char temp[MAXLINE];
*size=0;
strcpy(returnString,"");
fseek(readFile,0,0);
for(i=0;i<nbLines;i++)
{
fgets(str,100,readFile);
printf("%s",str);
fgets(temp,100,readFile);
*size+=strlen(temp);
strcat(returnString,temp);
}
}
int getFileSize(FILE * readFile)
{
fseek(readFile,0,2);
int returnValue = ftell(readFile);
fseek(readFile,0,0);
return returnValue;
}
/**
* @brief Debug uniquement : récupère une ligne, non optimisé donc inutilisable
*
* @param string la chaîne de caractère à analyser
* @param line int la ligne à récupérer
* @return char* la ligne sous un string
*/
char * getLine(char * string,int line)
{
int j=0,k=0;
char * returnString = (char *)(malloc(MAXLINE*sizeof(char)));
for(int i=0;i<line;i++)
{
k=0;
strcpy(returnString,"");
while(*(string+j) != '\n')
{
*(returnString+k)=*(string+j);
j++;
k++;
}
j++;
}
*(returnString+k)='\0';
return returnString;
}
void string2Coureur(char * string,int nbLines)
{
int j=0;
for(int i=3;i<=nbLines;i++)
{
switch(j)
{
case 0:
printf("Nom de l'equipe : %s\n",getLine(string,i));
break;
default:
printf("Coureur : %s\n",getLine(string,i));
}
j++;
if(j>5)
{
j=0;
printf("\n");
}
}
}