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> #include <stdbool.h>
int getNbLines(FILE * readFile); 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 main(void)
{ {
int size;
FILE * f=fopen ("fichier_coureurs.txt","r"); FILE * f=fopen ("fichier_coureurs.txt","r");
//printf("Number of lines : %d\n",getNbLines(f)); char * fileString = (char *)(malloc(getFileSize(f)*sizeof(char)));
getLines(f,getNbLines(f)); 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; 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 * initElement(void)
{ {
struct element * returnElement = (struct element *)malloc(sizeof(struct element)); struct element * returnElement = (struct element *)malloc(sizeof(struct element));
@ -17,6 +28,12 @@ struct element * initElement(void)
return returnElement; return returnElement;
} }
/**
* @brief initialise chaque element de la liste a partir de initElement
*
*
* @return l
*/
liste initListe(void) liste initListe(void)
{ {
liste l; liste l;
@ -69,24 +86,42 @@ void printlist(liste l)
printf("NULL \n"); printf("NULL \n");
} }
/**
* @brief Mettre le poiteur courant d'une liste sur le premiere element
void allerDebut(liste * l)// car demandee dans le TP zero reference *
* @param l liste ou l'on modifie le poiteur courant
*/
void allerDebut(liste * l)
{ {
l->courant = l->debut; 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; 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; 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; return l->courant->coureurActuel;
} }
@ -97,95 +132,160 @@ coureur * coureurCourant(liste * l)// car demandee dans le TP zero reference
* fonctionnement : * fonctionnement :
-declaration d'un poiteur eParcours egale l'adresse du premiere element (variable temporaire) -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 -declaration d'un poiteur(ePrevious) qui stockera temporairement l'adresse des elements pendant la reconstruction du chainage
- -si l'element a supprimer est le premiere element de la liste :
* @param listeActuel -le poiteur courant pointe sur l'element suivant
* @param coureurSuppr -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) void effacerCoureur(liste * listeActuel,coureur * coureurSuppr)
{ {
struct element *eParcours =listeActuel->debut; struct element *eParcours =listeActuel->debut;
struct element * ePrevious; 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->courant=eParcours->suiv;
listeActuel->debut=eParcours->suiv; //le poiteur pointant sur le premiere element poite sur le deuxieme listeActuel->debut=eParcours->suiv;
} }
else{ //si l'element a suppr n'est pas le deuxieme else{
ePrevious=eParcours; //ePrevious egale l'adresse du premiere element ePrevious=eParcours;
eParcours=eParcours->suiv; //eParcours egale l'adresse du deuxieme element eParcours=eParcours->suiv;
while(eParcours->coureurActuel != coureurSuppr){ //tant que l'element poitee par eParcours ne contient pas le courreur a supprimer faire : while(eParcours->coureurActuel != coureurSuppr){
ePrevious=ePrevious->suiv; //ePrevious pointe sur l'element suivant ePrevious=ePrevious->suiv;
eParcours=eParcours->suiv; //eParcours pointe sur l'element suivant 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 ePrevious->suiv=eParcours->suiv;
free(eParcours); //supression de l'element 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 tailleListe(liste l)
{ {
int returnValue=0; //initilisation a 0 d'un compteur (int) int returnValue=0;
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 struct element * elementActuel = l.debut;
while(elementActuel->suiv != l.fin->suiv) //tant que elementActuel n'est pas egale a l'adresse du derniere element faire : while(elementActuel->suiv != l.fin->suiv)
{ {
returnValue++; //increment compteur returnValue++;
elementActuel=elementActuel->suiv; //elementActuel pointe sur l'element suivant 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) 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++) 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) 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 * elementDebut = l->debut;
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 struct element * elementPrecedent = (struct element *)(malloc(sizeof(struct element)));
for(int i=0;i<nb;i++) //pour i allant de 0 a nb-1 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; elementDebut=elementDebut->suiv;
} }
struct element * elementSuivant = elementDebut->suiv; //declaration de elementsuivant qui poite sur l'element nb+1 struct element * elementSuivant = elementDebut->suiv;
elementDebut->suiv=elementSuivant->suiv; //elementCourant pointe sur nb+1 elementDebut->suiv=elementSuivant->suiv;
elementSuivant->suiv=elementDebut; //elementSuivant pointe sur nb elementSuivant->suiv=elementDebut;
if(nb==0) //si l'element a intervertir est le premier : if(nb==0)
{ {
l->courant=elementSuivant; //le poiteur courant pointe sur l'ancien deuxieme element l->courant=elementSuivant;
l->debut=l->courant; //le poiteur debut pointe sur l'ancien deuxieme l->debut=l->courant;
} }
else{ //si l'element a intervertir diff du premier : else{
elementPrecedent->suiv = elementSuivant; //element nb-1 pointe sur element nb elementPrecedent->suiv = elementSuivant;
l->courant=l->debut; //le poiteur courant pointe sur le premier element 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 j=0;j<=i-1;j++)
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++) //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);
{ tabOrdered = false;
invertCoureur(l,j); //inverser les courreurs
tabOrdered = false;
}
//printlist(*l);
}
if(tabOrdered)
{
return;
} }
printlist(*l);
}
if(tabOrdered)
{
return;
} }
} }
}

69
src/readfile.c
View file

@ -1,4 +1,5 @@
#include "../header/readfile.h" #include "../header/readfile.h"
#define MAXLINE 50
int getNbLines(FILE * readFile) int getNbLines(FILE * readFile)
{ {
@ -13,14 +14,74 @@ int getNbLines(FILE * readFile)
return count+1; return count+1;
} }
char * getLines(FILE * readFile,int nbLines) void getStringFromFile(FILE * readFile,int nbLines,char * returnString,int * size)
{ {
int i; int i;
char str[100]; char temp[MAXLINE];
*size=0;
strcpy(returnString,"");
fseek(readFile,0,0); fseek(readFile,0,0);
for(i=0;i<nbLines;i++) for(i=0;i<nbLines;i++)
{ {
fgets(str,100,readFile); fgets(temp,100,readFile);
printf("%s",str); *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");
}
} }
} }