diff --git a/BTS/C/Deuxieme annee/bonhommeFork.c b/BTS/C/Deuxieme annee/bonhommeFork.c new file mode 100644 index 0000000..cfe35b3 --- /dev/null +++ b/BTS/C/Deuxieme annee/bonhommeFork.c @@ -0,0 +1,61 @@ +#include +#include + +//Les variables testFourchetteX correspondent aux fourchette de séparation d'un processus. + +int main() +{ + int testFourchette1, testFourchette2, testFourchette3, testFourchette4, testFourchette5, testFourchette6; + testFourchette1 = fork(); + if(testFourchette1 == 0) //Je suis P3, l'enfant de P1 + { + boite("Boite 3"); + testFourchette2 = fork(); + if(testFourchette2 == 0) //Je suis P2, l'enfant de P3 + { + boite("Boite 2"); + } + else //Je suis P3 + { + testFourchette3 = fork(); + if(testFourchette3 == 0) //Je suis P4, l'enfant de P3 + { + boite("Boite 4"); + } + else //Je suis P3, l'enfant de P1 + { + testFourchette4 = fork(); + if(testFourchette4 == 0) //Je suis P5, l'enfant de P3 + { + boite("Boite 5"); + testFourchette5 = fork(); + if(testFourchette5 == 0) //Je suis P6, l'enfant de P5 + { + boite("Boite 6"); + } + else //Je suis P5, l'enfant de P3 + { + testFourchette6 = fork(); + if(testFourchette6 == 0) //Je suis P7, l'enfant de P5 + { + boite("Boite 7"); + } + else //Je suis P5, l'enfant de P3 + { + boite("Boite 5"); + } + } + } + else //Je suis P3, l'enfant de P1 + { + boite("Boite 3"); + } + } + } + } + else //Je suis P1 + { + boite("Boite 1"); + } + return EXIT_SUCCESS; +} diff --git a/BTS/C/Deuxieme annee/chatSocketSelectServer.c b/BTS/C/Deuxieme annee/chatSocketSelectServer.c new file mode 100644 index 0000000..20dad61 --- /dev/null +++ b/BTS/C/Deuxieme annee/chatSocketSelectServer.c @@ -0,0 +1,110 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define BACKLOG 5 +#define MAX 512 + +int main() +{ + + fd_set rfds; + struct timeval tv; + + struct sockaddr_in infoServer; + struct sockaddr_in retourServer; + socklen_t tailleInfoServ; + int retourSocket; + int retourBind; + int retourListen; + int retourAccept; + int retourRead; + int retourWrite; + char msg[MAX]; + + infoServer.sin_family = AF_INET; + infoServer.sin_addr.s_addr = htonl(INADDR_ANY); + infoServer.sin_port = htons(3434); + + retourSocket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); + if(retourSocket == -1) + { + printf("Erreur socket\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + retourBind = bind(retourSocket, (struct sockaddr *)&infoServer, sizeof(infoServer)); + if(retourBind == -1) + { + printf("Erreur bind\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + retourListen = listen(retourSocket, BACKLOG); + if(retourListen == -1) + { + printf("Erreur listen\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + printf("Attente d'une connexion.\n\n"); + + tailleInfoServ = sizeof(retourServer); + retourAccept = accept(retourSocket, (struct sockaddr *)&retourServer, &tailleInfoServ); + if(retourAccept == -1) + { + printf("Erreur accept\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + while(1) + { + FD_ZERO(&rfds); + FD_SET(0, &rfds); + tv.tv_sec = 5; + tv.tv_usec = 0; + + printf("Attente d'un nouveau message...\n\n"); + + if(select(retourSocket+1, &rfds, NULL, NULL, &tv)) + { + retourRead = read(retourAccept, &msg, sizeof(msg)); + if(retourRead == -1) + { + printf("Erreur read\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + printf("Nouveau message \n"); + printf("IP : %s:%d: %s\n\n", inet_ntoa(retourServer.sin_addr), ntohs(retourServer.sin_port), msg); + + } + + printf("Message : "); + gets(msg); + printf("\n\n"); + + retourWrite = write(retourAccept, &msg, sizeof(msg)); + if(retourWrite == -1) + { + printf("Erreur write\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + } + close(retourAccept); + return 0; +} diff --git a/BTS/C/Deuxieme annee/fileMessageP1/main.c b/BTS/C/Deuxieme annee/fileMessageP1/main.c new file mode 100644 index 0000000..09d7379 --- /dev/null +++ b/BTS/C/Deuxieme annee/fileMessageP1/main.c @@ -0,0 +1,39 @@ +#include +#include +#include +#include +#include +#include +#include "zone.h" +#include +#include + +float randomF() +{ + return ((float)100.0*(rand()/(RAND_MAX+0.1))); +} + +int main() +{ + int i; + zone maZoneMemoire; + + key_t clef; + int msqid; + + clef = ftok("/tmp/bidon", 5678); + + msqid = msgget(clef, 0666 | IPC_CREAT); + if(msqid == -1) + { + printf("Erreur creation file message : %s\n", strerror(errno)); + } + + while(1) + { + maZoneMemoire.type = randomF(); + msgsnd(msqid, (struct msgbuf *) &maZoneMemoire, sizeof(maZoneMemoire), 0); + printf("Nouveau message envoye.\n"); + usleep(99999); + } +} diff --git a/BTS/C/Deuxieme annee/fileMessageP1/zone.h b/BTS/C/Deuxieme annee/fileMessageP1/zone.h new file mode 100644 index 0000000..025cf98 --- /dev/null +++ b/BTS/C/Deuxieme annee/fileMessageP1/zone.h @@ -0,0 +1,9 @@ +#ifndef ZONE_H_INCLUDED +#define ZONE_H_INCLUDED + +typedef struct donnees{ + long type; + char texte; +}zone; + +#endif // ZONE_H_INCLUDED diff --git a/BTS/C/Deuxieme annee/fileMessageP2/main.c b/BTS/C/Deuxieme annee/fileMessageP2/main.c new file mode 100644 index 0000000..06b673d --- /dev/null +++ b/BTS/C/Deuxieme annee/fileMessageP2/main.c @@ -0,0 +1,39 @@ +#include +#include +#include +#include +#include +#include +#include "zone.h" +#include +#include + +float randomC() +{ + return ((char)('A'+((char)(25.0*(rand()/(RAND_MAX+0.1)))))); +} + +int main() +{ + int i; + zone maZoneMemoire; + + key_t clef; + int msqid; + + clef = ftok("/tmp/bidon", 5678); + + msqid = msgget(clef, 0666 | IPC_CREAT); + if(msqid == -1) + { + printf("Erreur creation file message : %s\n", strerror(errno)); + } + + while(1) + { + maZoneMemoire.texte = (char)randomC(); + msgsnd(msqid, (struct msgbuf *) &maZoneMemoire, sizeof(maZoneMemoire), 0); + printf("Nouveau message envoye.\n"); + usleep(99999); + } +} diff --git a/BTS/C/Deuxieme annee/fileMessageP2/zone.h b/BTS/C/Deuxieme annee/fileMessageP2/zone.h new file mode 100644 index 0000000..025cf98 --- /dev/null +++ b/BTS/C/Deuxieme annee/fileMessageP2/zone.h @@ -0,0 +1,9 @@ +#ifndef ZONE_H_INCLUDED +#define ZONE_H_INCLUDED + +typedef struct donnees{ + long type; + char texte; +}zone; + +#endif // ZONE_H_INCLUDED diff --git a/BTS/C/Deuxieme annee/fileMessageP3/main.c b/BTS/C/Deuxieme annee/fileMessageP3/main.c new file mode 100644 index 0000000..2e5c757 --- /dev/null +++ b/BTS/C/Deuxieme annee/fileMessageP3/main.c @@ -0,0 +1,35 @@ +#include +#include +#include +#include +#include +#include +#include "zone.h" +#include +#include + +int main() +{ + zone maZoneMemoire; + + key_t clef; + int msqid; + + + clef = ftok("/tmp/bidon", 5678); + + msqid = msgget(clef, 0600 | IPC_CREAT); + if(msqid == -1) + { + printf("Erreur creation file message : %s\n", strerror(errno)); + } + + while(1) + { + msgrcv(msqid, (struct msgbuf *) &maZoneMemoire, sizeof(maZoneMemoire), 0, 0); + printf("%ul %c\n", maZoneMemoire.type, maZoneMemoire.texte); + usleep(99999); + } + + return 0; +} diff --git a/BTS/C/Deuxieme annee/fileMessageP3/zone.h b/BTS/C/Deuxieme annee/fileMessageP3/zone.h new file mode 100644 index 0000000..025cf98 --- /dev/null +++ b/BTS/C/Deuxieme annee/fileMessageP3/zone.h @@ -0,0 +1,9 @@ +#ifndef ZONE_H_INCLUDED +#define ZONE_H_INCLUDED + +typedef struct donnees{ + long type; + char texte; +}zone; + +#endif // ZONE_H_INCLUDED diff --git a/BTS/C/Deuxieme annee/forkElevesTP.c b/BTS/C/Deuxieme annee/forkElevesTP.c new file mode 100644 index 0000000..2e7846c --- /dev/null +++ b/BTS/C/Deuxieme annee/forkElevesTP.c @@ -0,0 +1,26 @@ +#include +#include + +int main ( int argc, char *argv[] ) +{ + int pid1,pid2; + pid1 = fork(); + if ( pid1 == 0 ) + { + boite("boite1","pid1=0"); + pid2 = fork(); + if ( pid2 == 0 ) + { + boite("boite2","pid2=0"); + } + else + { + boite("boite3","pid2<>0"); + } + } + else + { + boite("boite4","pid1<>0"); + } + return EXIT_SUCCESS; +} diff --git a/BTS/C/Deuxieme annee/jeparleagrandpere.c b/BTS/C/Deuxieme annee/jeparleagrandpere.c new file mode 100644 index 0000000..022b16e --- /dev/null +++ b/BTS/C/Deuxieme annee/jeparleagrandpere.c @@ -0,0 +1,8 @@ +#include +#include + +int main() +{ + printf("Hello world!\n"); + return 0; +} diff --git a/BTS/C/Deuxieme annee/memShareP1.c b/BTS/C/Deuxieme annee/memShareP1.c new file mode 100644 index 0000000..ba9fbdb --- /dev/null +++ b/BTS/C/Deuxieme annee/memShareP1.c @@ -0,0 +1,48 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +typedef struct { + float temp; + int press; + char ordre; +}uneStruct; + +float randomF(){ + return ((float)100.0*(rand()/(RAND_MAX+0.1))); +} + +int randomI(){ + return ((int)100.0*(rand()/(RAND_MAX+0.1))); +} + +int main() +{ + uneStruct *memShare; + int shmid; + key_t clef; + void *shm; + + clef = ftok("/tmp/bidon", 1234); + shmid = shmget(clef, sizeof(uneStruct), 0666); + if(shmid < 0) + { + perror("Erreur shmget"); + exit(EXIT_FAILURE); + } + + memShare = shmat(shmid, NULL, 0); + + while(1) + { + memShare->press = randomI(); + memShare->temp = randomF(); + printf("Memoire mise a jour.\nVal->\n\tpress : %d, temp : %f\n\n", memShare->press, memShare->temp); + usleep(999999); + } +} diff --git a/BTS/C/Deuxieme annee/memShareP2.c b/BTS/C/Deuxieme annee/memShareP2.c new file mode 100644 index 0000000..0ec10ee --- /dev/null +++ b/BTS/C/Deuxieme annee/memShareP2.c @@ -0,0 +1,43 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +typedef struct { + float temp; + int press; + char ordre; +}uneStruct; + +char randomC(){ + return ((char)126.0*(rand()/(RAND_MAX+0.1))); +} + +int main() +{ + uneStruct *memShare; + int shmid; + key_t clef; + void *shm; + + clef = ftok("/tmp/bidon", 1234); + shmid = shmget(clef, sizeof(uneStruct), 0666); + if(shmid < 0) + { + perror("Erreur shmget"); + exit(EXIT_FAILURE); + } + + memShare = shmat(shmid, NULL, 0); + + while(1) + { + memShare->ordre = randomC(); + printf("Memoire mise a jour.\nVal->\n\tordre : %c\n\n", memShare->ordre); + usleep(999999); + } +} diff --git a/BTS/C/Deuxieme annee/memShareP3.c b/BTS/C/Deuxieme annee/memShareP3.c new file mode 100644 index 0000000..fe6e79b --- /dev/null +++ b/BTS/C/Deuxieme annee/memShareP3.c @@ -0,0 +1,36 @@ +#include +#include +#include +#include +#include + +typedef struct { + float temp; + int press; + char ordre; +}uneStruct; + +int main() +{ + int shmid, loop = 0; + char *shm; + uneStruct *sharedStruct; + key_t clef; + + clef = ftok("/tmp/bidon", 1234); + shmid = shmget(clef, sizeof(uneStruct), IPC_CREAT | 0666); + if(shmid < 0) + { + perror("Erreur shmget"); + exit(EXIT_FAILURE); + } + sharedStruct = shmat(shmid, NULL, 0); + + while(1) + { + loop++; + printf("Loop %d\t|%d\t|%f\t| %c\n", loop, sharedStruct->temp, sharedStruct->press, sharedStruct->ordre); + usleep(999999); + } + return 0; +} diff --git a/BTS/C/Deuxieme annee/popen.c b/BTS/C/Deuxieme annee/popen.c new file mode 100644 index 0000000..aa7e4e3 --- /dev/null +++ b/BTS/C/Deuxieme annee/popen.c @@ -0,0 +1,47 @@ +#include +#include +#include +#include +#define BUFSIZ 255 + +int main() +{ + int nbOctets; + int descTube[2]; + int descTube2[2]; + char chaine[] = "Salut papa!"; + char buffer[BUFSIZ]; + pid_t pid; + memset(buffer, '\0', BUFSIZ); + + if ( pipe(descTube) == 0 && pipe(descTube2) == 0) + { + pid = fork(); // duplication du processus + if (pid == -1) // oups un probleme + { + fprintf(stderr, "Pb de fork"); + exit(EXIT_FAILURE); + } + + else // fork ok + { + if (pid == 0) // je suis dans le process fils + { + nbOctets = read(descTube[0], buffer, BUFSIZ); + nbOctets = write(descTube2[1], chaine, strlen(chaine)); + printf("%d octets ecrits\n", nbOctets); + printf("octets lus: %d: %s\n", nbOctets, buffer); + exit(EXIT_SUCCESS); + } + else //je suis dans le process pere + { + strcpy(chaine, "test"); + nbOctets = write(descTube[1], chaine, strlen(chaine)); + nbOctets = read(descTube2[0], buffer, BUFSIZ); + printf("%d octets ecrits\n", nbOctets); + printf("octets lus: %d: %s\n", nbOctets, buffer); + } + } + } + exit(EXIT_SUCCESS); +} diff --git a/BTS/C/Deuxieme annee/selectTCPServer.c b/BTS/C/Deuxieme annee/selectTCPServer.c new file mode 100644 index 0000000..dec0030 --- /dev/null +++ b/BTS/C/Deuxieme annee/selectTCPServer.c @@ -0,0 +1,101 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define BACKLOG 5 + +int main() +{ + fd_set rfds; + struct timeval tv; + + int retval; + + struct sockaddr_in infoServer; + struct sockaddr_in retourServer; + socklen_t tailleRetourServ; + int retourSocket; + int retourBind; + int retourListen; + int retourAccept; + int retourRead; + int retourWrite; + int msg; + + infoServer.sin_family = AF_INET; + infoServer.sin_addr.s_addr = htonl(INADDR_ANY); + infoServer.sin_port = htons(3434); + + FD_ZERO(&rfds); + FD_SET(0, &rfds); + + tv.tv_sec = 5; + tv.tv_usec = 0; + + retval = select(1, &rfds, NULL, NULL, &tv); + + retourSocket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); + if(retourSocket == -1) + { + printf("Erreur socket\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + retourBind = bind(retourSocket, (struct sockaddr *)&infoServer, sizeof(infoServer)); + + if(retourBind == -1) + { + printf("Erreur bind\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + retourListen = listen(retourSocket, BACKLOG); + + if(retourListen == -1) + { + printf("Erreur listen\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + tailleRetourServ = sizeof(retourServer); + retourAccept = accept(retourSocket, (struct sockaddr *)&retourServer, &tailleRetourServ); + + if(retourAccept == -1) + { + printf("Erreur accept\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + retourRead = read(retourAccept, &msg, sizeof(msg)); + + if(retourRead == -1) + { + printf("Erreur recv\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + printf("%d", msg); + msg = -msg; + + retourWrite = write(retourAccept, &msg, sizeof(msg)); + if(retourWrite == -1) + { + printf("Erreur sendto\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + return 0; +} diff --git a/BTS/C/Deuxieme annee/semaphoreP1/main.c b/BTS/C/Deuxieme annee/semaphoreP1/main.c new file mode 100644 index 0000000..8bd855f --- /dev/null +++ b/BTS/C/Deuxieme annee/semaphoreP1/main.c @@ -0,0 +1,80 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include "semtools.h" + +typedef struct +{ + float temp; + int press; + char ordre; +} uneStruct; + +float randomF() +{ + return ((float)100.0*(rand()/(RAND_MAX+0.1))); +} + +int randomI() +{ + return ((int)100.0*(rand()/(RAND_MAX+0.1))); +} + +int main() +{ + uneStruct *memShare; + int shmid; + key_t clef; + void *shm; + + clef = ftok("/tmp/bidon", 5678); + shmid = shmget(clef, sizeof(uneStruct), 0666); + if(shmid < 0) + { + perror("Erreur shmget"); + exit(EXIT_FAILURE); + } + + //debut sem + id_sem = semget (5678, 1, IPC_CREAT | 0600); + if (id_sem == -1) + { + printf("Probleme semget : %s\n", strerror(errno)); + if(errno != EEXIST) + { + exit(errno); + } + } + if(fixe_valeursem() == 0) + { + exit(0); + } + //fin init sem + + memShare = shmat(shmid, NULL, 0); + + while(1) + { + if(P() == 1) + { + memShare->press = randomI(); + memShare->temp = randomF(); + printf("Memoire mise a jour.\nVal->\n\tpress : %d, temp : %f\n\n", memShare->press, memShare->temp); + + if(V() == 0) + { + exit(EXIT_FAILURE); + } + } + else + { + exit(EXIT_FAILURE); + } + usleep(999999); + } +} diff --git a/BTS/C/Deuxieme annee/semaphoreP1/semtools.c b/BTS/C/Deuxieme annee/semaphoreP1/semtools.c new file mode 100644 index 0000000..cd0a89b --- /dev/null +++ b/BTS/C/Deuxieme annee/semaphoreP1/semtools.c @@ -0,0 +1,56 @@ +/****************************************************** +Fichier : semtools.c +Boite a outils pour manipuler des semaphores +******************************************************/ + +#include "semtools.h" + +int fixe_valeursem(){ + union semun sem_union; + sem_union.val = 1; + int retour = 1; + printf("id_sem dans fixe_valeur = %d\n",id_sem); + if (semctl(id_sem,0,SETVAL,/*sem_union*/1) == -1){ + printf("impossible de creer le semaphore\n%s\n",strerror(errno)); + retour = 0; + } + return(retour); +} + +void supp_valeursem(){ + union semun sem_union; + + if (semctl(id_sem,0,IPC_RMID,sem_union) == -1){ + printf("impossible de supprimer le semaphore\n%s\n",strerror(errno)); + } +} + + + +int P(){ + struct sembuf sem_b; + int retour = 1; + sem_b.sem_num = 0; + sem_b.sem_op = -1; //P() + sem_b.sem_flg = SEM_UNDO ; + if (semop(id_sem,&sem_b,1) == -1){ + printf("echec semaphore P()\n%s\n",strerror(errno)); + retour = 0 ; + } + return(retour); +} + +int V(){ + struct sembuf sem_b; + int retour=1; + + sem_b.sem_num = 0; + sem_b.sem_op = 1; //V() + sem_b.sem_flg = SEM_UNDO ; + if (semop(id_sem,&sem_b,1) == -1){ + printf("echec semaphore V()\n%s\n",strerror(errno)); + retour = 0 ; + } + return(retour); +} + diff --git a/BTS/C/Deuxieme annee/semaphoreP1/semtools.h b/BTS/C/Deuxieme annee/semaphoreP1/semtools.h new file mode 100755 index 0000000..0836d28 --- /dev/null +++ b/BTS/C/Deuxieme annee/semaphoreP1/semtools.h @@ -0,0 +1,39 @@ +/****************************************************** +Fichier : semtools.h +Boite a outils pour manipuler des semaphores +******************************************************/ + +#include +#include +#include +#include +#include +#include +#include + +#ifndef _SEMTOOLS_H +#define _SEMTOOLS_H +// identifiant de semaphore +int id_sem; +// fixe la valeur du sempahore +int fixe_valeursem(); +// supprime le semaphore +void supp_valeursem(); +// modification de la valeur du semaphore de -1 (attente) +int P(); +// modification de la valeur du semaphore de 1 (sem dispo) +int V(); + +#if defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED) + /* l'union semun est dfinie par l'inclusion de */ + #else + /* d'aprs X/OPEN il faut la dfinir nous-mmes */ + union semun { + int val; /* valeur pour SETVAL */ + struct semid_ds *buf; /* buffer pour IPC_STAT, IPC_SET */ + unsigned short *array; /* table pour GETALL, SETALL */ + /* Spcificit Linux : */ + struct seminfo *__buf; /* buffer pour IPC_INFO */ + }; +#endif +#endif \ No newline at end of file diff --git a/BTS/C/Deuxieme annee/semaphoreP2/main.c b/BTS/C/Deuxieme annee/semaphoreP2/main.c new file mode 100644 index 0000000..1975ca0 --- /dev/null +++ b/BTS/C/Deuxieme annee/semaphoreP2/main.c @@ -0,0 +1,75 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include "semtools.h" + +typedef struct +{ + float temp; + int press; + char ordre; +} uneStruct; + +char randomC() +{ + return ((char)126.0*(rand()/(RAND_MAX+0.1))); +} + +int main() +{ + uneStruct *memShare; + int shmid; + key_t clef; + void *shm; + + clef = ftok("/tmp/bidon", 5678); + shmid = shmget(clef, sizeof(uneStruct), 0666); + if(shmid < 0) + { + perror("Erreur shmget"); + exit(EXIT_FAILURE); + } + + //debut sem + id_sem = semget (5678, 1, IPC_CREAT | 0600); + if (id_sem == -1) + { + printf("Probleme semget : %s\n", strerror(errno)); + if(errno != EEXIST) + { + exit(errno); + } + } + if(fixe_valeursem() == 0) + { + exit(0); + } + //fin init sem + + memShare = shmat(shmid, NULL, 0); + + while(1) + { + if(P() == 1) + { + memShare->ordre = randomC(); + printf("Memoire mise a jour.\nVal->\n\tordre : %c\n\n", memShare->ordre); + + + if(V() == 0) + { + exit(EXIT_FAILURE); + } + } + else + { + exit(EXIT_FAILURE); + } + usleep(999999); + } +} diff --git a/BTS/C/Deuxieme annee/semaphoreP2/semtools.c b/BTS/C/Deuxieme annee/semaphoreP2/semtools.c new file mode 100644 index 0000000..cd0a89b --- /dev/null +++ b/BTS/C/Deuxieme annee/semaphoreP2/semtools.c @@ -0,0 +1,56 @@ +/****************************************************** +Fichier : semtools.c +Boite a outils pour manipuler des semaphores +******************************************************/ + +#include "semtools.h" + +int fixe_valeursem(){ + union semun sem_union; + sem_union.val = 1; + int retour = 1; + printf("id_sem dans fixe_valeur = %d\n",id_sem); + if (semctl(id_sem,0,SETVAL,/*sem_union*/1) == -1){ + printf("impossible de creer le semaphore\n%s\n",strerror(errno)); + retour = 0; + } + return(retour); +} + +void supp_valeursem(){ + union semun sem_union; + + if (semctl(id_sem,0,IPC_RMID,sem_union) == -1){ + printf("impossible de supprimer le semaphore\n%s\n",strerror(errno)); + } +} + + + +int P(){ + struct sembuf sem_b; + int retour = 1; + sem_b.sem_num = 0; + sem_b.sem_op = -1; //P() + sem_b.sem_flg = SEM_UNDO ; + if (semop(id_sem,&sem_b,1) == -1){ + printf("echec semaphore P()\n%s\n",strerror(errno)); + retour = 0 ; + } + return(retour); +} + +int V(){ + struct sembuf sem_b; + int retour=1; + + sem_b.sem_num = 0; + sem_b.sem_op = 1; //V() + sem_b.sem_flg = SEM_UNDO ; + if (semop(id_sem,&sem_b,1) == -1){ + printf("echec semaphore V()\n%s\n",strerror(errno)); + retour = 0 ; + } + return(retour); +} + diff --git a/BTS/C/Deuxieme annee/semaphoreP2/semtools.h b/BTS/C/Deuxieme annee/semaphoreP2/semtools.h new file mode 100755 index 0000000..0836d28 --- /dev/null +++ b/BTS/C/Deuxieme annee/semaphoreP2/semtools.h @@ -0,0 +1,39 @@ +/****************************************************** +Fichier : semtools.h +Boite a outils pour manipuler des semaphores +******************************************************/ + +#include +#include +#include +#include +#include +#include +#include + +#ifndef _SEMTOOLS_H +#define _SEMTOOLS_H +// identifiant de semaphore +int id_sem; +// fixe la valeur du sempahore +int fixe_valeursem(); +// supprime le semaphore +void supp_valeursem(); +// modification de la valeur du semaphore de -1 (attente) +int P(); +// modification de la valeur du semaphore de 1 (sem dispo) +int V(); + +#if defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED) + /* l'union semun est dfinie par l'inclusion de */ + #else + /* d'aprs X/OPEN il faut la dfinir nous-mmes */ + union semun { + int val; /* valeur pour SETVAL */ + struct semid_ds *buf; /* buffer pour IPC_STAT, IPC_SET */ + unsigned short *array; /* table pour GETALL, SETALL */ + /* Spcificit Linux : */ + struct seminfo *__buf; /* buffer pour IPC_INFO */ + }; +#endif +#endif \ No newline at end of file diff --git a/BTS/C/Deuxieme annee/semaphoreP3/main.c b/BTS/C/Deuxieme annee/semaphoreP3/main.c new file mode 100644 index 0000000..b013bf5 --- /dev/null +++ b/BTS/C/Deuxieme annee/semaphoreP3/main.c @@ -0,0 +1,66 @@ +#include +#include +#include +#include +#include +#include "semtools.h" + +typedef struct +{ + float temp; + int press; + char ordre; +} uneStruct; + +int main() +{ + int shmid, loop = 0; + uneStruct *sharedStruct; + key_t clef; + + clef = ftok("/tmp/bidon", 5678); + shmid = shmget(clef, sizeof(uneStruct), IPC_CREAT | 0666); + if(shmid < 0) + { + perror("Erreur shmget"); + exit(EXIT_FAILURE); + } + + //debut sem + id_sem = semget (5678, 1, IPC_CREAT | 0600); + if (id_sem == -1) + { + printf("pb semget: %s\n",strerror(errno)); + if (errno!=EEXIST) + { + exit(errno); + } + } + if ( fixe_valeursem()== 0) + { + exit ( 0 ); + } + //fin init sem + + sharedStruct = shmat(shmid, NULL, 0); + + while(1) + { + if(P() == 1) + { + printf("Loop %d\t|%d\t|%f\t| %c\n", loop, sharedStruct->temp, sharedStruct->press, sharedStruct->ordre); + + if(V() == 0) + { + exit(EXIT_FAILURE); + } + } + else + { + exit(EXIT_FAILURE); + } + loop++; + usleep(999999); + } + return 0; +} diff --git a/BTS/C/Deuxieme annee/semaphoreP3/semtools.c b/BTS/C/Deuxieme annee/semaphoreP3/semtools.c new file mode 100644 index 0000000..cd0a89b --- /dev/null +++ b/BTS/C/Deuxieme annee/semaphoreP3/semtools.c @@ -0,0 +1,56 @@ +/****************************************************** +Fichier : semtools.c +Boite a outils pour manipuler des semaphores +******************************************************/ + +#include "semtools.h" + +int fixe_valeursem(){ + union semun sem_union; + sem_union.val = 1; + int retour = 1; + printf("id_sem dans fixe_valeur = %d\n",id_sem); + if (semctl(id_sem,0,SETVAL,/*sem_union*/1) == -1){ + printf("impossible de creer le semaphore\n%s\n",strerror(errno)); + retour = 0; + } + return(retour); +} + +void supp_valeursem(){ + union semun sem_union; + + if (semctl(id_sem,0,IPC_RMID,sem_union) == -1){ + printf("impossible de supprimer le semaphore\n%s\n",strerror(errno)); + } +} + + + +int P(){ + struct sembuf sem_b; + int retour = 1; + sem_b.sem_num = 0; + sem_b.sem_op = -1; //P() + sem_b.sem_flg = SEM_UNDO ; + if (semop(id_sem,&sem_b,1) == -1){ + printf("echec semaphore P()\n%s\n",strerror(errno)); + retour = 0 ; + } + return(retour); +} + +int V(){ + struct sembuf sem_b; + int retour=1; + + sem_b.sem_num = 0; + sem_b.sem_op = 1; //V() + sem_b.sem_flg = SEM_UNDO ; + if (semop(id_sem,&sem_b,1) == -1){ + printf("echec semaphore V()\n%s\n",strerror(errno)); + retour = 0 ; + } + return(retour); +} + diff --git a/BTS/C/Deuxieme annee/semaphoreP3/semtools.h b/BTS/C/Deuxieme annee/semaphoreP3/semtools.h new file mode 100755 index 0000000..0836d28 --- /dev/null +++ b/BTS/C/Deuxieme annee/semaphoreP3/semtools.h @@ -0,0 +1,39 @@ +/****************************************************** +Fichier : semtools.h +Boite a outils pour manipuler des semaphores +******************************************************/ + +#include +#include +#include +#include +#include +#include +#include + +#ifndef _SEMTOOLS_H +#define _SEMTOOLS_H +// identifiant de semaphore +int id_sem; +// fixe la valeur du sempahore +int fixe_valeursem(); +// supprime le semaphore +void supp_valeursem(); +// modification de la valeur du semaphore de -1 (attente) +int P(); +// modification de la valeur du semaphore de 1 (sem dispo) +int V(); + +#if defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED) + /* l'union semun est dfinie par l'inclusion de */ + #else + /* d'aprs X/OPEN il faut la dfinir nous-mmes */ + union semun { + int val; /* valeur pour SETVAL */ + struct semid_ds *buf; /* buffer pour IPC_STAT, IPC_SET */ + unsigned short *array; /* table pour GETALL, SETALL */ + /* Spcificit Linux : */ + struct seminfo *__buf; /* buffer pour IPC_INFO */ + }; +#endif +#endif \ No newline at end of file diff --git a/BTS/C/Deuxieme annee/serverSocket/main.c b/BTS/C/Deuxieme annee/serverSocket/main.c new file mode 100644 index 0000000..bf4d8b5 --- /dev/null +++ b/BTS/C/Deuxieme annee/serverSocket/main.c @@ -0,0 +1,46 @@ +#include "socketBibli.h" + +int main() +{ + int socket; + int choix; + + socket = demarrage(); + + while(1) + { + printf("Type de donner a transmettre :\n"); + printf("1- Int\n"); + printf("2- Float\n"); + printf("3- Char\n"); + printf("Choix : "); + + scanf("%d", &choix); + switch (choix) + { + case 1 : + + printf("Demarrage reussi, en attente de donnees.\n"); + dialogueInt(socket); + break; + case 2 : + + printf("Demarrage reussi, en attente de donnees.\n"); + dialogueFloat(socket); + + break; + case 3 : + + printf("Demarrage reussi, en attente de donnees.\n"); + dialogueChar(socket); + + break; + default : + + printf("Reponse non conforme."); + break; + } + } + + return 0; +} diff --git a/BTS/C/Deuxieme annee/serverSocket/socketBibli.c b/BTS/C/Deuxieme annee/serverSocket/socketBibli.c new file mode 100644 index 0000000..76a2c87 --- /dev/null +++ b/BTS/C/Deuxieme annee/serverSocket/socketBibli.c @@ -0,0 +1,111 @@ +#include "socketBibli.h" + +void mort(char *cituation) +{ + printf("Erreur avec le dernier paquet recu, probleme %s : %s \n", cituation, strerror(errno)); +} + +int demarrage() +{ + struct sockaddr_in infoServer; + int retourSocket; + int port; + + printf("Port sur lequel vous voulez lancer le serveur :"); + scanf("%d", &port); + + infoServer.sin_family = AF_INET; + infoServer.sin_addr.s_addr = htonl(INADDR_ANY); + infoServer.sin_port = htons(port); + + retourSocket = socket(AF_INET, SOCK_DGRAM, 0); + + if(retourSocket == -1) + { + mort("demarrage socket"); + } + + if(bind(retourSocket, (struct sockaddr *)&infoServer, sizeof(infoServer)) == -1) + { + mort("bind"); + } + + return retourSocket; + +} + +void dialogueInt(int socket) +{ + struct sockaddr_in infoClient; + int infoClientTaille; + int retourMsg; + int retourSendTo; + + while(1) + { + if(recvfrom(socket, &retourMsg, sizeof(retourMsg), 0, (struct sockaddr *)&infoClient, &infoClientTaille) == -1) + { + mort("recvfrom"); + exit(errno); + } + + printf("%d\n", retourMsg); + + if(sendto(socket, &retourMsg, sizeof(retourMsg), 0, (struct sockaddr *)&infoClient, sizeof(infoClient))==-1) + { + mort("sendto"); + exit(errno); + } + + } + +} + +void dialogueFloat(int socket) +{ + struct sockaddr_in infoClient; + int infoClientTaille; + float retourMsg; + + while(1) + { + if(recvfrom(socket, &retourMsg, sizeof(retourMsg), 0, (struct sockaddr *)&infoClient, &infoClientTaille) == -1) + { + mort("recvfrom"); + exit(errno); + } + + printf("%f\n", retourMsg); + + if(sendto(socket, &retourMsg, sizeof(retourMsg), 0, (struct sockaddr *)&infoClient, sizeof(infoClient))==-1) + { + mort("sendto"); + exit(errno); + } + + } +} + +void dialogueChar(int socket) +{ + struct sockaddr_in infoClient; + int infoClientTaille; + char retourMsg[CHARLEN]; + int retourSendTo; + + while(1) + { + if(recvfrom(socket, &retourMsg, sizeof(retourMsg), 0, (struct sockaddr *)&infoClient, &infoClientTaille) == -1) + { + mort("recvfrom"); + } + + printf("%s\n", retourMsg); + + if(sendto(socket, &retourMsg, sizeof(retourMsg), 0, (struct sockaddr *)&infoClient, sizeof(infoClient))==-1) + { + mort("sendto"); + } + + } +} diff --git a/BTS/C/Deuxieme annee/serverSocket/socketBibli.h b/BTS/C/Deuxieme annee/serverSocket/socketBibli.h new file mode 100644 index 0000000..d01222e --- /dev/null +++ b/BTS/C/Deuxieme annee/serverSocket/socketBibli.h @@ -0,0 +1,22 @@ +#ifndef SOCKETBIBLI_H_INCLUDED +#define SOCKETBIBLI_H_INCLUDED + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define CHARLEN 512 + +void mort(char *cituation); +int demarrage(); +void dialogueInt(int socket); +void dialogueChar(int socket); +void dialogueFloat(int socket); + +#endif // SOCKETBIBLI_H_INCLUDED diff --git a/BTS/C/Deuxieme annee/serveurHTTP.c b/BTS/C/Deuxieme annee/serveurHTTP.c new file mode 100644 index 0000000..111b7c6 --- /dev/null +++ b/BTS/C/Deuxieme annee/serveurHTTP.c @@ -0,0 +1,89 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define BACKLOG 5 + + +int main() +{ + struct sockaddr_in infoServer; + struct sockaddr_in retourServer; + socklen_t tailleInfoServ; + int retourSocket; + int retourBind; + int retourListen; + int retourAccept; + int retourRead; + int retourWrite; + char html[]= "HTTP/1.0 200 OK\nContent-Length:68\nContent-Type: text/html\n\ncc

slt

"; + char msg[512]; + + infoServer.sin_family = AF_INET; + infoServer.sin_addr.s_addr = htonl(INADDR_ANY); + infoServer.sin_port = htons(8080); + + retourSocket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); + if(retourSocket == -1) + { + printf("Erreur socket\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + retourBind = bind(retourSocket, (struct sockaddr *)&infoServer, sizeof(infoServer)); + if(retourBind == -1) + { + printf("Erreur bind\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + retourListen = listen(retourSocket, BACKLOG); + if(retourListen == -1) + { + printf("Erreur listen\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + tailleInfoServ = sizeof(retourServer); + while(1){ + retourAccept = accept(retourSocket, (struct sockaddr *)&retourServer, &tailleInfoServ); + if(retourAccept == -1) + { + printf("Erreur accept\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + retourRead = read(retourAccept, &msg, sizeof(msg)); + if(retourRead == -1) + { + printf("Erreur read\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + printf("Nouvelle requete \n"); + printf("IP : %s:%d", retourServer.sin_addr, retourServer.sin_port); + + retourWrite = write(retourAccept, &html, sizeof(html)); + if(retourWrite == -1) + { + printf("Erreur write\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + close(retourAccept); + } + return 0; +} diff --git a/BTS/C/Deuxieme annee/signauxQ1.c b/BTS/C/Deuxieme annee/signauxQ1.c new file mode 100644 index 0000000..8da60d1 --- /dev/null +++ b/BTS/C/Deuxieme annee/signauxQ1.c @@ -0,0 +1,50 @@ +#include +#include +#include +#include +#include +#include +#include + +// fonction de traitement du signal SIGUSR1 +void traitement(int sig) +{ + (void) signal(SIGUSR1, traitement); + printf("un signal SIGUSR1 ppid :%d\n", getppid()); +} + + +int main(int argc, char *argv[]) +{ + int pid; + (void) signal(SIGUSR1, traitement); // rederoutage des signaux SIGUSR1 + // vers la fonction traitement + pid = fork(); + + if (pid == -1) + { + printf("pb creation fork : %s\n", strerror(errno)); + exit(1); + } + else + { + if (pid == 0) // process fils + { + printf("fils pid=%d\n", getpid()); + kill(getppid(), SIGUSR1); + sleep(2); // tempo pour être certain que le fils sera + //encore vivant quand le pere lui + //enverra son signal + } + else // process principal (pere) + { + printf("pere pid=%d\n", getpid()); + kill(pid, SIGUSR1); + sleep(2); // tempo pour être certain que le pere sera + //encore vivant quand le fils lui + //enverra son signal + } + } + + return EXIT_SUCCESS; +} diff --git a/BTS/C/Deuxieme annee/signauxQ2.c b/BTS/C/Deuxieme annee/signauxQ2.c new file mode 100644 index 0000000..ba064c8 --- /dev/null +++ b/BTS/C/Deuxieme annee/signauxQ2.c @@ -0,0 +1,71 @@ +#include +#include +#include +#include +#include +#include +#include + +void traitement(int sig) +{ + + (void ) signal(SIGUSR1, traitement); + printf("Un signal SIGUSR1 ppid : %d %d\n", getppid(), getpid()); +} + +int main(int argc, char *argv[]) +{ + int pid; + int pid2; + int pid2temp; + (void) signal(SIGUSR1, traitement); + pid = fork(); + pid2temp = pid; + + if (pid == -1) + { + printf("pb creation fork : %s\n", strerror(errno)); + exit(1); + } + else + { + if (pid == 0) // process fils + { + pid2 = fork(); + if(pid2 == -1) + { + printf("Pb creation fork :%s\n", strerror(errno)); + exit(1); + } + else + { + if(pid2 == 0)// Process fils du fils + { + printf("fils P3 pid=%d\n", getpid()); + kill(pid2temp, SIGUSR1); + sleep(2); // tempo pour être certain que le fils sera + //encore vivant quand le pere lui + //enverra son signal + } + else //process fils + { + printf("fils P2 pid=%d\n", getpid()); + sleep(2); // tempo pour être certain que le fils sera + //encore vivant quand le pere lui + //enverra son signal + } + } + + } + else // process principal (pere) + { + kill(pid2temp, SIGUSR1); + printf("pere pid=%d\n", getpid()); + sleep(2); // tempo pour être certain que le pere sera + //encore vivant quand le fils lui + //enverra son signal + } + } + + return EXIT_SUCCESS; +} diff --git a/BTS/C/Deuxieme annee/signauxQ3.c b/BTS/C/Deuxieme annee/signauxQ3.c new file mode 100644 index 0000000..022b16e --- /dev/null +++ b/BTS/C/Deuxieme annee/signauxQ3.c @@ -0,0 +1,8 @@ +#include +#include + +int main() +{ + printf("Hello world!\n"); + return 0; +} diff --git a/BTS/C/Deuxieme annee/socketChat.c b/BTS/C/Deuxieme annee/socketChat.c new file mode 100644 index 0000000..1abcec2 --- /dev/null +++ b/BTS/C/Deuxieme annee/socketChat.c @@ -0,0 +1,95 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define BACKLOG 5 +#define MAX 512 + + +int main() +{ + struct sockaddr_in infoServer; + struct sockaddr_in retourServer; + socklen_t tailleInfoServ; + int retourSocket; + int retourBind; + int retourListen; + int retourAccept; + int retourRead; + int retourWrite; + char msg[MAX]; + + infoServer.sin_family = AF_INET; + infoServer.sin_addr.s_addr = htonl(INADDR_ANY); + infoServer.sin_port = htons(3434); + + retourSocket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); + if(retourSocket == -1) + { + printf("Erreur socket\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + retourBind = bind(retourSocket, (struct sockaddr *)&infoServer, sizeof(infoServer)); + if(retourBind == -1) + { + printf("Erreur bind\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + retourListen = listen(retourSocket, BACKLOG); + if(retourListen == -1) + { + printf("Erreur listen\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + tailleInfoServ = sizeof(retourServer); + retourAccept = accept(retourSocket, (struct sockaddr *)&retourServer, &tailleInfoServ); + if(retourAccept == -1) + { + printf("Erreur accept\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + while(1) + { + + retourRead = read(retourAccept, &msg, sizeof(msg)); + if(retourRead == -1) + { + printf("Erreur read\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + printf("Nouveau message \n"); + printf("IP : %s:%d: %s\n\n", inet_ntoa(retourServer.sin_addr), ntohs(retourServer.sin_port), msg); + + printf("Message : "); + gets(msg); + printf("\n\n"); + + retourWrite = write(retourAccept, &msg, sizeof(msg)); + if(retourWrite == -1) + { + printf("Erreur write\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + } + close(retourAccept); + return 0; +} diff --git a/BTS/C/Deuxieme annee/socketChatClient.c b/BTS/C/Deuxieme annee/socketChatClient.c new file mode 100644 index 0000000..6d177c6 --- /dev/null +++ b/BTS/C/Deuxieme annee/socketChatClient.c @@ -0,0 +1,79 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define LEN 512 + +int main() +{ + struct sockaddr_in infoServeur; + struct sockaddr_in infoServeurRetour; + char msg[LEN]; + int infoServeurRetourTaille; + int retourSocket; + int retourConnect; + int retourRead; + int retourWrite; + int socketFd; + + infoServeur.sin_addr.s_addr = inet_addr("172.18.58.93"); + infoServeur.sin_family = AF_INET; + infoServeur.sin_port = htons(3434); + + retourSocket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); + if(retourSocket == -1) + { + printf("Erreur socket\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + retourConnect = connect(retourSocket, &infoServeur, sizeof(infoServeur)); + if(retourSocket == -1) + { + printf("Erreur connect\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + while (1) + { + printf("Message :"); + gets(msg); + + retourWrite = write(retourSocket, &msg, sizeof(msg), 0, (struct sockaddr *)&infoServeur, sizeof(infoServeur)); + if(retourSocket == -1) + { + printf("Erreur write\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + //if(select()) + //{ + retourRead = read(retourSocket, &msg, sizeof(msg), 0, (struct sockaddr *)&infoServeurRetour, sizeof(infoServeurRetour)); + if(retourRead == -1) + { + printf("Erreur read\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + printf("Message de %s:%d\n", inet_ntoa(infoServeur.sin_addr), ntohs(infoServeur.sin_port)); + printf("%s\n", msg); + + //} + + + } + + close(retourSocket); + + return 0; +} diff --git a/BTS/C/Deuxieme annee/socketClient/main.c b/BTS/C/Deuxieme annee/socketClient/main.c new file mode 100644 index 0000000..2794a8e --- /dev/null +++ b/BTS/C/Deuxieme annee/socketClient/main.c @@ -0,0 +1,37 @@ +#include "socketBibli.h" + +int main() +{ + struct sockaddr_in *infoServeur; + int retourSocket; + int choix; + + retourSocket = connection(&infoServeur); + + while(1) + { + printf("Donnee transferes par le serveur : \n"); + printf("1- Int\n"); + printf("2- Float\n"); + printf("3- Char\n"); + printf("Choix :"); + scanf("%d", &choix); + switch (choix) + { + case 1: + dialogueInt(retourSocket, &infoServeur); + break; + case 2: + dialogueFloat(retourSocket, &infoServeur); + break; + case 3: + dialogueChar(retourSocket, &infoServeur); + break; + default: + printf("Mauvais choix"); + exit(0); + } + } + + return 0; +} diff --git a/BTS/C/Deuxieme annee/socketClient/socketBibli.c b/BTS/C/Deuxieme annee/socketClient/socketBibli.c new file mode 100644 index 0000000..9ce47ca --- /dev/null +++ b/BTS/C/Deuxieme annee/socketClient/socketBibli.c @@ -0,0 +1,104 @@ +#include "socketBibli.h" + +void mort(char *cituation) +{ + printf("Erreur avec le dernier paquet recu, probleme %s : %s \n", cituation, strerror(errno)); +} + +int connection(struct sockaddr_in *infoServeur) +{ + char IP[16]; + int port; + int retourSocket; + + printf("IP du serveur cible : "); + scanf("%s", &IP); + + printf("Port du serveur cible : "); + scanf("%d", &port); + + infoServeur->sin_addr.s_addr = inet_addr(IP); + infoServeur->sin_family = AF_INET; + infoServeur->sin_port = htons(port); + + retourSocket = socket(PF_INET, SOCK_DGRAM, 0); + + if(retourSocket==-1) + { + mort("socket"); + } + + return retourSocket; +} + +void dialogueInt(int retourSocket, struct sockaddr_in *infoServeur) +{ + int msg; + struct sockaddr_in infoServeurRetour; + int infoServeurRetourTaille; + + while(1) + { + printf("Message (int) :"); + scanf("%d", &msg); + + if(sendto(retourSocket, &msg, sizeof(msg), 0, (struct sockaddr *)&infoServeur, sizeof(infoServeur)) == -1) + { + mort("sendto"); + } + + if(recvfrom(retourSocket, &msg, sizeof(msg), 0, (struct sockaddr *)&infoServeurRetour, &infoServeurRetourTaille) == -1) + { + mort("resvfrom"); + } + + } +} + +void dialogueFloat(int retourSocket, struct sockaddr_in *infoServeur) +{ + float msg; + struct sockaddr_in infoServeurRetour; + int infoServeurRetourTaille; + + while(1) + { + printf("Message (float) :"); + scanf("%f", &msg); + + if(sendto(retourSocket, &msg, sizeof(msg), 0, (struct sockaddr *)&infoServeur, sizeof(infoServeur)) == -1) + { + mort("sendto"); + } + + if(recvfrom(retourSocket, &msg, sizeof(msg), 0, (struct sockaddr *)&infoServeurRetour, &infoServeurRetourTaille)) + { + mort("resvfrom"); + } + + } +} + +void dialogueChar(int retourSocket, struct sockaddr_in *infoServeur) +{ + char msg[LONGCHAR]; + struct sockaddr_in infoServeurRetour; + int infoServeurRetourTaille; + + while(1) + { + printf("Message (float) :"); + scanf("%s", &msg); + + if(sendto(retourSocket, &msg, sizeof(msg), 0, (struct sockaddr *)&infoServeur, sizeof(infoServeur)) == -1) + { + mort("sendto"); + } + + if(recvfrom(retourSocket, &msg, sizeof(msg), 0, (struct sockaddr *)&infoServeurRetour, &infoServeurRetourTaille)) + { + mort("resvfrom"); + } + + } +} diff --git a/BTS/C/Deuxieme annee/socketClient/socketBibli.h b/BTS/C/Deuxieme annee/socketClient/socketBibli.h new file mode 100644 index 0000000..013cbe1 --- /dev/null +++ b/BTS/C/Deuxieme annee/socketClient/socketBibli.h @@ -0,0 +1,22 @@ +#ifndef SOCKETBIBLI_H_INCLUDED +#define SOCKETBIBLI_H_INCLUDED + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define LONGCHAR 512 + +void mort(char *cituation); +int connection(struct sockaddr_in *infoServeur); +void dialogueInt(int retourSocket, struct sockaddr_in *infoServeur); +void dialogueChar(int retourSocket, struct sockaddr_in *infoServeur); +void dialogueFloat(int retourSocket, struct sockaddr_in *infoServeur); + +#endif // SOCKETBIBLI_H_INCLUDED diff --git a/BTS/C/Deuxieme annee/socketClientTCP.c b/BTS/C/Deuxieme annee/socketClientTCP.c new file mode 100644 index 0000000..179368c --- /dev/null +++ b/BTS/C/Deuxieme annee/socketClientTCP.c @@ -0,0 +1,80 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +typedef struct{ + unsigned char jour; + unsigned char mois; + unsigned short int annee; + char jourDeLaSemaine[10]; +}datePerso; + +int main() +{ + datePerso perso; + datePerso retourPerso; + struct sockaddr_in infoServeur; + struct sockaddr_in infoServeurRetour; + int infoServeurRetourTaille; + int retourSocket; + int retourConnect; + int retourRead; + int retourWrite; + int socketFd; + int retourMsg; + + int msg = 8; + + perso.jour = 17; + perso.mois = 12; + perso.annee = 1997; + strcpy(perso.jourDeLaSemaine, "Lundi"); + + infoServeur.sin_addr.s_addr = inet_addr("172.18.58.142"); + infoServeur.sin_family = AF_INET; + infoServeur.sin_port = htons(5555); + + retourSocket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); + if(retourSocket == -1) + { + printf("Erreur socket\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + retourConnect = connect(retourSocket, &infoServeur, sizeof(infoServeur)); + if(retourSocket == -1) + { + printf("Erreur connect\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + retourWrite = write(retourSocket, &msg, sizeof(msg), 0, (struct sockaddr *)&infoServeur, sizeof(infoServeur)); + if(retourSocket == -1) + { + printf("Erreur write\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + retourRead = read(retourSocket, &retourMsg, sizeof(retourMsg), 0, (struct sockaddr *)&infoServeurRetour, &infoServeurRetourTaille); + if(retourSocket == -1) + { + printf("Erreur read\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + printf("%d", retourMsg); + + close(retourSocket); + + return 0; +} diff --git a/BTS/C/Deuxieme annee/socketServeurTCP.c b/BTS/C/Deuxieme annee/socketServeurTCP.c new file mode 100644 index 0000000..64eb45c --- /dev/null +++ b/BTS/C/Deuxieme annee/socketServeurTCP.c @@ -0,0 +1,88 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define BACKLOG 5 + +int main() +{ + struct sockaddr_in infoServer; + struct sockaddr_in retourServer; + socklen_t tailleRetourServ; + int retourSocket; + int retourBind; + int retourListen; + int retourAccept; + int retourRead; + int retourWrite; + int msg; + + infoServer.sin_family = AF_INET; + infoServer.sin_addr.s_addr = htonl(INADDR_ANY); + infoServer.sin_port = htons(5555); + + retourSocket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); + if(retourSocket == -1) + { + printf("Erreur socket\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + retourBind = bind(retourSocket, (struct sockaddr *)&infoServer, sizeof(infoServer)); + + if(retourBind == -1) + { + printf("Erreur bind\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + retourListen = listen(retourSocket, BACKLOG); + + if(retourListen == -1) + { + printf("Erreur listen\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + tailleRetourServ = sizeof(retourServer); + retourAccept = accept(retourSocket, (struct sockaddr *)&retourServer, &tailleRetourServ); + + if(retourAccept == -1) + { + printf("Erreur accept\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + retourRead = read(retourAccept, &msg, sizeof(msg)); + + if(retourRead == -1) + { + printf("Erreur recv\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + printf("%d", msg); + msg = -msg; + + retourWrite = write(retourAccept, &msg, sizeof(msg)); + if(retourWrite == -1) + { + printf("Erreur sendto\n"); + printf("%s", strerror(errno)); + exit(errno); + } + + return 0; +} diff --git a/BTS/C/Deuxieme annee/testFork.c b/BTS/C/Deuxieme annee/testFork.c new file mode 100644 index 0000000..0eeb2fa --- /dev/null +++ b/BTS/C/Deuxieme annee/testFork.c @@ -0,0 +1,11 @@ +#include +#include + +int main() +{ + fork(); + fork(); + fork(); + printf("* "); + return 0; +} diff --git a/BTS/C/Deuxieme annee/testFork2.c b/BTS/C/Deuxieme annee/testFork2.c new file mode 100644 index 0000000..67abfb4 --- /dev/null +++ b/BTS/C/Deuxieme annee/testFork2.c @@ -0,0 +1,33 @@ +#include +#include + +int main() +{ + int pid1, pid2, pid3; + pid1 = fork(); + if (pid1 == 0) + { + printf("p1\n"); + } + else + { + pid2 = fork(); + if (pid2 == 0) + { + printf("p2\n"); + } + else + { + pid3 = fork(); + if (pid3 == 0) + { + printf("p3\n"); + } + else + { + printf("p4\n"); + } + } + } + return 0; +} diff --git a/BTS/C/Deuxieme annee/testFork3.c b/BTS/C/Deuxieme annee/testFork3.c new file mode 100644 index 0000000..022b16e --- /dev/null +++ b/BTS/C/Deuxieme annee/testFork3.c @@ -0,0 +1,8 @@ +#include +#include + +int main() +{ + printf("Hello world!\n"); + return 0; +} diff --git a/BTS/C/Deuxieme annee/threadTD.c b/BTS/C/Deuxieme annee/threadTD.c new file mode 100644 index 0000000..65ab744 --- /dev/null +++ b/BTS/C/Deuxieme annee/threadTD.c @@ -0,0 +1,86 @@ +#include +#include +#include +#include +#include + +typedef struct { + int v1; + int v2; + int v3; +}laStruct; + +laStruct maStruct; + +void *fonction_update1 () +{ + maStruct.v1 = 1; +} + +void *fonction_update2 () +{ + maStruct.v2 = 2; +} + +void *fonction_update3 () +{ + maStruct.v3 = 3; +} + +int main() +{ + int resultat; + pthread_t un_thread; + pthread_t deux_thread; + pthread_t trois_thread; + void *thread_result; + + resultat = pthread_create(&un_thread, NULL, fonction_update1, NULL); + + if (resultat != 0) { + perror("Thread creation failed"); + exit(EXIT_FAILURE); + } + + resultat = pthread_create(&deux_thread, NULL, fonction_update2, NULL); + + if (resultat != 0) { + perror("Thread creation failed"); + exit(EXIT_FAILURE); + } + + resultat = pthread_create(&trois_thread, NULL, fonction_update3, NULL); + + if (resultat != 0) { + perror("Thread creation failed"); + exit(EXIT_FAILURE); + } + + printf("Attente de la fin du thread...\n"); + + resultat = pthread_join(un_thread, &thread_result); + if (resultat != 0) { + perror("Thread join a foir... echoué"); + exit(EXIT_FAILURE); + } + + printf("Attente de la fin du thread...\n"); + + resultat = pthread_join(deux_thread, &thread_result); + if (resultat != 0) { + perror("Thread join a foir... echoué"); + exit(EXIT_FAILURE); + } + + printf("Attente de la fin du thread...\n"); + + resultat = pthread_join(trois_thread, &thread_result); + if (resultat != 0) { + perror("Thread join a foir... echoué"); + exit(EXIT_FAILURE); + } + + printf("%d\n%d\n%d\n", maStruct.v1, maStruct.v2, maStruct.v3); + exit(EXIT_SUCCESS); + return 0; +} diff --git a/BTS/C/Deuxieme annee/threadTDQ2/bin/Debug/threadTDQ2 b/BTS/C/Deuxieme annee/threadTDQ2/bin/Debug/threadTDQ2 new file mode 100755 index 0000000..5e3022d Binary files /dev/null and b/BTS/C/Deuxieme annee/threadTDQ2/bin/Debug/threadTDQ2 differ diff --git a/BTS/C/Deuxieme annee/threadTDQ2/obj/Debug/main.o b/BTS/C/Deuxieme annee/threadTDQ2/obj/Debug/main.o new file mode 100644 index 0000000..3d447b7 Binary files /dev/null and b/BTS/C/Deuxieme annee/threadTDQ2/obj/Debug/main.o differ diff --git a/BTS/C/Deuxieme annee/threadTDQ2/threadTDQ2.c b/BTS/C/Deuxieme annee/threadTDQ2/threadTDQ2.c new file mode 100644 index 0000000..5c06962 --- /dev/null +++ b/BTS/C/Deuxieme annee/threadTDQ2/threadTDQ2.c @@ -0,0 +1,87 @@ +#include +#include +#include +#include +#include + +typedef struct { + int v1; + int v2; + int v3; +}laStruct; + +laStruct maStruct; + +void *fonction_update1 (int val) +{ + maStruct.v1 = val; +} + +void *fonction_update2 (int val) +{ + maStruct.v2 = val; +} + +void *fonction_update3 (int val) +{ + maStruct.v3 = val; +} + +int main() +{ + int resultat; + pthread_t un_thread; + pthread_t deux_thread; + pthread_t trois_thread; + void *thread_result; + int val[3] = {1, 3, 5}; + + resultat = pthread_create(&un_thread, NULL, fonction_update1, (void *) val[0]); + + if (resultat != 0) { + perror("Thread creation failed"); + exit(EXIT_FAILURE); + } + + resultat = pthread_create(&deux_thread, NULL, fonction_update2, (void *) val[1]); + + if (resultat != 0) { + perror("Thread creation failed"); + exit(EXIT_FAILURE); + } + + resultat = pthread_create(&trois_thread, NULL, fonction_update3, (void *) val[2]); + + if (resultat != 0) { + perror("Thread creation failed"); + exit(EXIT_FAILURE); + } + + printf("Attente de la fin du thread...\n"); + + resultat = pthread_join(un_thread, &thread_result); + if (resultat != 0) { + perror("Thread join a foir... echoué"); + exit(EXIT_FAILURE); + } + + printf("Attente de la fin du thread...\n"); + + resultat = pthread_join(deux_thread, &thread_result); + if (resultat != 0) { + perror("Thread join a foir... echoué"); + exit(EXIT_FAILURE); + } + + printf("Attente de la fin du thread...\n"); + + resultat = pthread_join(trois_thread, &thread_result); + if (resultat != 0) { + perror("Thread join a foir... echoué"); + exit(EXIT_FAILURE); + } + + printf("%d\n%d\n%d\n", maStruct.v1, maStruct.v2, maStruct.v3); + exit(EXIT_SUCCESS); + return 0; +} diff --git a/BTS/C/Deuxieme annee/threadTDQ2/threadTDQ2.cbp b/BTS/C/Deuxieme annee/threadTDQ2/threadTDQ2.cbp new file mode 100644 index 0000000..debf6f4 --- /dev/null +++ b/BTS/C/Deuxieme annee/threadTDQ2/threadTDQ2.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/BTS/C/Deuxieme annee/threadTDQ2/threadTDQ2.depend b/BTS/C/Deuxieme annee/threadTDQ2/threadTDQ2.depend new file mode 100644 index 0000000..e48bd76 --- /dev/null +++ b/BTS/C/Deuxieme annee/threadTDQ2/threadTDQ2.depend @@ -0,0 +1,8 @@ +# depslib dependency file v1.0 +1475661104 source:/home/USERS/ELEVES/SNIR2015/therbron/Workspace/C/threadTDQ2/main.c + + + + + + diff --git a/BTS/C/Deuxieme annee/threadTDQ2/threadTDQ2.layout b/BTS/C/Deuxieme annee/threadTDQ2/threadTDQ2.layout new file mode 100644 index 0000000..69282d5 --- /dev/null +++ b/BTS/C/Deuxieme annee/threadTDQ2/threadTDQ2.layout @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/BTS/C/Deuxieme annee/threadTDQ3/bin/Debug/threadTDQ3 b/BTS/C/Deuxieme annee/threadTDQ3/bin/Debug/threadTDQ3 new file mode 100755 index 0000000..6efaf2a Binary files /dev/null and b/BTS/C/Deuxieme annee/threadTDQ3/bin/Debug/threadTDQ3 differ diff --git a/BTS/C/Deuxieme annee/threadTDQ3/main.c b/BTS/C/Deuxieme annee/threadTDQ3/main.c new file mode 100644 index 0000000..c021682 --- /dev/null +++ b/BTS/C/Deuxieme annee/threadTDQ3/main.c @@ -0,0 +1,96 @@ +#include +#include +#include +#include +#include + +typedef struct { + int v1; + int v2; + int v3; +}laStruct; + +laStruct maStruct; + +pthread_mutex_t mutex; + +void *fonction_update (int val[]) +{ + pthread_mutex_lock(&mutex); + maStruct.v1 = val[0]; + maStruct.v2 = val[1]; + maStruct.v3 = val[2]; + printf("Valeur en cours de Thread :\n\t%d\t%d\t%d\n\n",maStruct.v1, maStruct.v2, maStruct.v3); + pthread_mutex_unlock(&mutex); +} + +int main() +{ + pthread_t un_thread; + pthread_t deux_thread; + pthread_t trois_thread; + + void *thread_result; + int resultat; + int valT1[3] = {1, 3, 5}; + int valT2[3] = {2, 4, 6}; + int valT3[3] = {10, 20, 30}; + int retourMutex; + pthread_mutexattr_t mutexattr = PTHREAD_MUTEX_INITIALIZER; + + retourMutex = pthread_mutex_init(&mutex, &mutexattr); + if (retourMutex != 0) + { + perror("Erreur peu probable dans l'initialisation du mutex."); + exit(EXIT_FAILURE); + } + + resultat = pthread_create(&un_thread, NULL, fonction_update, (void *) valT1); + if (resultat != 0) { + perror("Thread creation failed"); + exit(EXIT_FAILURE); + } + + printf("Attente de la fin du thread...\n"); + + resultat = pthread_create(&deux_thread, NULL, fonction_update, (void *) valT2); + if (resultat != 0) { + perror("Thread creation failed"); + exit(EXIT_FAILURE); + } + + printf("Attente de la fin du thread...\n"); + + + resultat = pthread_create(&trois_thread, NULL, fonction_update, (void *) valT3); + if (resultat != 0) { + perror("Thread creation failed"); + exit(EXIT_FAILURE); + } + + printf("Attente de la fin du thread...\n"); + + resultat = pthread_join(un_thread, &thread_result); + if (resultat != 0) { + perror("Thread join a foir... echoué"); + exit(EXIT_FAILURE); + } + + resultat = pthread_join(deux_thread, &thread_result); + if (resultat != 0) { + perror("Thread join a foir... echoué"); + exit(EXIT_FAILURE); + } + + resultat = pthread_join(trois_thread, &thread_result); + if (resultat != 0) { + perror("Thread join a foir... echoué"); + exit(EXIT_FAILURE); + } + + pthread_mutex_lock(&mutex); + printf("Val finale :\n\t%d\t%d\t%d\n", maStruct.v1, maStruct.v2, maStruct.v3); + pthread_mutex_unlock(&mutex); + exit(EXIT_SUCCESS); + return 0; +} diff --git a/BTS/C/Deuxieme annee/threadTDQ3/obj/Debug/main.o b/BTS/C/Deuxieme annee/threadTDQ3/obj/Debug/main.o new file mode 100644 index 0000000..55f58e3 Binary files /dev/null and b/BTS/C/Deuxieme annee/threadTDQ3/obj/Debug/main.o differ diff --git a/BTS/C/Deuxieme annee/threadTDQ3/threadTDQ3.cbp b/BTS/C/Deuxieme annee/threadTDQ3/threadTDQ3.cbp new file mode 100644 index 0000000..4e513d6 --- /dev/null +++ b/BTS/C/Deuxieme annee/threadTDQ3/threadTDQ3.cbp @@ -0,0 +1,47 @@ + + + + + + diff --git a/BTS/C/Deuxieme annee/threadTDQ3/threadTDQ3.depend b/BTS/C/Deuxieme annee/threadTDQ3/threadTDQ3.depend new file mode 100644 index 0000000..1206fbe --- /dev/null +++ b/BTS/C/Deuxieme annee/threadTDQ3/threadTDQ3.depend @@ -0,0 +1,8 @@ +# depslib dependency file v1.0 +1475825404 source:/home/USERS/ELEVES/SNIR2015/therbron/Workspace/C/threadTDQ3/main.c + + + + + + diff --git a/BTS/C/Deuxieme annee/threadTDQ3/threadTDQ3.layout b/BTS/C/Deuxieme annee/threadTDQ3/threadTDQ3.layout new file mode 100644 index 0000000..0069115 --- /dev/null +++ b/BTS/C/Deuxieme annee/threadTDQ3/threadTDQ3.layout @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/BTS/C/Deuxieme annee/threads.c b/BTS/C/Deuxieme annee/threads.c new file mode 100644 index 0000000..7be1a53 --- /dev/null +++ b/BTS/C/Deuxieme annee/threads.c @@ -0,0 +1,51 @@ +#include +#include +#include +#include +#include +#include + +char message[255]; + +typedef struct { + int v1; + int v2; + int v3; +}laStruct; + +void *ma_fonction_thread(void *arg) +{ + int tid = syscall(SYS_gettid); + printf("Le tid du thread est :%d\n", tid); + sleep(3); + strcpy(message, "Bye!"); + pthread_exit((void *) "Merci pour le temps CPU."); +} + +int main() +{ + int resultat; + pthread_t un_thread; + void *thread_result; + + strcpy(message, "Debian c'est cool."); + + resultat = pthread_create(&un_thread, NULL, ma_fonction_thread, (void *)message); + + if (resultat != 0) { + perror("Thread creation failed"); + exit(EXIT_FAILURE); + } + printf("PID du programme principal : %d\n", getpid()); + printf("Attente de la fin du thread...\n"); + + resultat = pthread_join(un_thread, &thread_result); + if (resultat != 0) { + perror("Thread join a foir... echoué"); + exit(EXIT_FAILURE); + } + + printf("OK, valeur de retour du Thread join :%s\n", (char *)thread_result); + printf("Le message est maintenant %s\n", message); + exit(EXIT_SUCCESS); +} diff --git a/BTS/C/Premiere annee/IMC.c b/BTS/C/Premiere annee/IMC.c new file mode 100644 index 0000000..8e424f2 --- /dev/null +++ b/BTS/C/Premiere annee/IMC.c @@ -0,0 +1,159 @@ +//Herbron Tanguy +//Calcul de l'IMC + +#include +#include + +int main() +{ + char nom[100]; + char prenom[100]; + char sexe; + char choixFormule; + float age; + int menu = 0; + float taille; + float poids; + float imc; + float poidsIdeal; + + printf("Bienvenue dans notre programme de calcul de l'IMC.\n"); + printf("Nous avons besoin de quelques renseignements.\n"); + printf("Votre nom: "); + gets(nom); + printf("Votre prénom: "); + gets(prenom); + printf("Votre sexe (h ou f): "); + scanf(" %c", &sexe); + while(sexe != 'h' && sexe != 'f') + { + printf("Saisie incorrecte, réessayez.\n"); + printf("Votre sexe (h ou f): "); + scanf(" %c", &sexe); + } + printf("Votre age: "); + scanf("%d", &age); + printf("Votre taille (en mètre): "); + scanf("%f", &taille); + printf("Votre poids (en kg): "); + scanf("%f", &poids); + printf("\n"); + + printf("Votre fiche récapitulative :\n"); + printf("- Identite : %s %s\n", prenom, nom); + printf("- Age : %.0f ans\n", age); + printf("- Poids : %.2f kg\n", poids); + printf("- Taille : %.2f m\n", taille); + + //Vérification du sexe pour une écriture plus correcte + if(sexe == 'h') + { + printf("- Sexe : homme\n\n"); + } + else + { + printf("- Sexe : femme\n\n"); + } + + imc = poids / (taille * taille); + + //Correspondance de la corpulence en fonction de l'IMC + if(imc <= 16.5) + { + printf("Votre indice de masse corporelle est de %.1f.\n", imc); + printf("Votre corpulence est qualifiée de famine.\n"); + } + else + { + if(imc <= 18.5) + { + printf("Votre indice de masse corporelle est de %.1f.\n", imc); + printf("Votre corpulence est qualifiée de maigreur.\n"); + } + else + { + if(imc <= 25) + { + printf("Votre indice de masse corporelle est de %.1f.\n", imc); + printf("Votre corpulence est qualifiée de normale.\n"); + } + else + { + if(imc <= 30) + { + printf("Votre indice de masse corporelle est de %.1f.\n", imc); + printf("Votre corpulence est qualifiée de surpoids.\n"); + } + else + { + if(imc <= 35) + { + printf("Votre indice de masse corporelle est de %.1f.\n", imc); + printf("Votre corpulence est qualifiée de obésité modéré.\n"); + } + else + { + if(imc <= 40) + { + printf("Votre indice de masse corporelle est de %.1f.\n", imc); + printf("Votre corpulence est qualifiée de obésité sévère.\n"); + } + else + { + printf("Votre indice de masse corporelle est de %.1f.\n", imc); + printf("Votre corpulence est qualifiée de obésité morbide.\n"); + } + } + } + } + } + } + + printf("\n"); + + do + { + printf("Calculez votre poids idéal :\n"); + printf("a - formule de Lorents\n"); + printf("b - formule de Devine\n"); + printf("c - formule de Lorents en tenant compte de l'age\n"); + printf("q - quitter le menu de calcul du poids idéal\n"); + printf("Votre choix: "); + scanf(" %c", &choixFormule); + + //Menu pour choisir le mode de calcul du poids idéal + switch (choixFormule) + { + case 'a': + if(sexe == 'h') + { + + } + + printf("Votre poids idéal selon la formule de Lorents est de %.1f kg.\n\n", poidsIdeal); + break; + case 'b': + if(sexe == 'h') + { + poidsIdeal = 50 + 2.3 * (taille / 0.0254 - 60); + } + else + { + poidsIdeal = 45.5 + 2.3 * (taille / 0.0254 - 60); + } + printf("Votre poids idéal selon la formule de Devine est de %.1f kg.\n\n", poidsIdeal); + break; + case 'c': + poidsIdeal = 50 + ((taille * 100 - 150) / 4) + ((age - 20) / 4); + printf("Votre poids idéal selon la formule de Lorents en tenant compte de l'age est de %.1f kg.\n\n", poidsIdeal); + break; + case 'q': + printf("Vous avez quitté le menu de calcul du poids idéal.\n"); + menu++; + break; + default: + printf("Caractère entré incorrecte. Réessayez.\n\n"); + } + } + while (menu == 0); +} diff --git a/BTS/C/Premiere annee/Monayeur/bibliotheque_perso.c b/BTS/C/Premiere annee/Monayeur/bibliotheque_perso.c new file mode 100644 index 0000000..151f2f5 --- /dev/null +++ b/BTS/C/Premiere annee/Monayeur/bibliotheque_perso.c @@ -0,0 +1,100 @@ +#include +#include +#define DELTA 0.001 + +double demanderBoisson() +{ + int choixBoisson; + double prixBoisson; + + printf("Choisissez votre boisson :\n"); + printf("1 - Café long [1.5€]\n"); + printf("2 - Café cours [0.8€]\n"); + printf("Votre choix :"); + scanf("%d", &choixBoisson); + switch (choixBoisson){ + case 1: + prixBoisson = 1.5; + break; + case 2: + prixBoisson = 0.8; + break; + } + return prixBoisson; +} + +double attendrePiece(double prixBoisson, int pieceUser[]) +{ + int piece; + double somme = 0; + + do{ + printf("Le prix est de %.1f€\n", prixBoisson); + printf("Monnaie :\n"); + printf("1 - 20€\n"); + printf("2 - 10€\n"); + printf("3 - 5€\n"); + printf("4 - 2€\n"); + printf("5 - 1€\n"); + printf("6 - 0.5€\n"); + printf("7 - 0.2€\n"); + printf("8 - 0.1€\n"); + printf("Piece a entrer :"); + scanf("%d", &piece); + switch (piece){ + case 1: + somme = somme + 20; + pieceUser[0]++; + break; + case 2: + somme = somme + 10; + pieceUser[1]++; + break; + case 3: + somme = somme + 5; + pieceUser[2]++; + break; + case 4: + somme = somme + 2; + pieceUser[3]++; + break; + case 5: + somme = somme + 1; + pieceUser[4]++; + break; + case 6: + somme = somme + 0.5; + pieceUser[5]++; + break; + case 7: + somme = somme + 0.2; + pieceUser[6]++; + break; + case 8: + somme = somme + 0.1; + pieceUser[7]++; + break; + } + printf("La somme que vous avez entree est de %.1f€\n", somme); + }while(prixBoisson > somme); + return somme - prixBoisson; +} + +double rendrePiece(double rendrePrix, double valPiece[], int nbPiece[], int pieceRendu[]) +{ + int boucle; +// mise à jours des pieces a rendre + for(boucle = 0; boucle < 8; boucle++){ + // je peux rendre des pieces de la valeur courante + if(valPiece[boucle] <= rendrePrix){ + // tant que je peux rendre des pieces de la valeur courante, je le fais + while((rendrePrix > (valPiece[boucle]-DELTA)) && (nbPiece[boucle] != 0)){ + rendrePrix = rendrePrix - valPiece[boucle]; + pieceRendu[boucle]++; + nbPiece[boucle]--; + } + } + } + + return rendrePrix; +} diff --git a/BTS/C/Premiere annee/Monayeur/bibliotheque_perso.h b/BTS/C/Premiere annee/Monayeur/bibliotheque_perso.h new file mode 100644 index 0000000..649fb20 --- /dev/null +++ b/BTS/C/Premiere annee/Monayeur/bibliotheque_perso.h @@ -0,0 +1,8 @@ +#ifndef BIBLIOTHEQUE_PERSO_H_INCLUDED +#define BIBLIOTHEQUE_PERSO_H_INCLUDED + +double demanderBoisson(); +double attendrePiece(double prixBoisson, int pieceUser[]); +double rendrePiece(double rendrePrix, double valPiece[], int nbPiece[], int pieceRendu[]); + +#endif // BIBLIOTHEQUE_PERSO_H_INCLUDED diff --git a/BTS/C/Premiere annee/Monayeur/main.c b/BTS/C/Premiere annee/Monayeur/main.c new file mode 100644 index 0000000..22fc785 --- /dev/null +++ b/BTS/C/Premiere annee/Monayeur/main.c @@ -0,0 +1,54 @@ +#include +#include +#include "bibliotheque_perso.h" + +int main() +{ + double valPiece[8] = {20, 10, 5, 2, 1, 0.5, 0.2, 0.1}; + double prixBoisson; + double valeurARendre; + int nbPiece[8] = {0, 0, 0, 5, 5, 8, 9, 12}; + int pieceUser[8] = {0, 0, 0, 0, 0}; + int pieceRendu[8] = {0, 0, 0, 0, 0}; + int choix; + int boucle; + + printf("Bonjour.\n"); + + do{ + printf("Que voulez-vous faire ?\n"); + printf("1 - Commander une boisson\n"); + printf("2 - Quitter\n"); + printf("Votre choix :"); + scanf("%d", &choix); + + switch (choix){ + case 1: + prixBoisson = demanderBoisson(); + valeurARendre = attendrePiece(prixBoisson, pieceUser); + printf("Somme à rendre : %.1f\n", valeurARendre); +// ajouter les pieces de l'usager dans le monnayeur + for(boucle = 0; boucle < 8; boucle++){ + nbPiece[boucle] = nbPiece[boucle] + pieceUser[boucle]; + } + + valeurARendre = rendrePiece(valeurARendre, valPiece, nbPiece, pieceRendu); + + printf("Pieces rendues :\n"); + for(boucle = 0; boucle < 8; boucle++){ + printf("%d piece de %.1f€\n", pieceRendu[boucle], valPiece[boucle]); + } + break; + case 2: + printf("Au revoir\n"); + break; + default: + printf("Saisie incorrecte\n"); + break; + } + + }while(choix != 2); + + + return 0; +} diff --git a/BTS/C/Premiere annee/Pendu/gestionPendu.c b/BTS/C/Premiere annee/Pendu/gestionPendu.c new file mode 100644 index 0000000..cb4a7e5 --- /dev/null +++ b/BTS/C/Premiere annee/Pendu/gestionPendu.c @@ -0,0 +1,119 @@ +#include "gestionPendu.h" + + + +int motEstTrouve(char *motATtrouver, char *motPropose){ + return(strcmp(motATtrouver,motPropose)); +} + + +int verifierLettrePropose(char *lettresProposees, int nbLettreProposee, char lettre) +{ + int lettreTrouve=1; + int i; + for(i = 0; i +#include +#include +#include +#include +#include +#include + +#ifndef _PENDU_H_ +#define _PENDU_H_ + + +#define NB_MAX_ERREUR 7 +#define NB_MAX_LETTRES_POSSIBLE 26 +#define NBMOTS 5 +// affiche un menu proposant de jouer ou de quitter +// recupère la réponse du joueur et retourne une valeur +// positive s'il veut jouer et négative sinon +int afficherMenu(); + +// affiche le pendu en fonction du nombre d'erreurs +// passee en parametre +void afficherPendu(int nroErreur); + +// Affiche les lettres deja proposees +// qui se trouve dans le tableau de lettre "histo" +// le nombre de lettre etant donne par nbLettre +void afficherLettre(char *histo, int nbLettre); + +// retourne 0 et le mot est trouve +int motEstTrouve(char *motATtrouver, char *motPropose); + +// remplace les - par la lettre propose dans le tableau mot courant +// si la lettre fait partie du mot a trouver +// retourne 1 si aucune lettre ne correspond, et 0 sinon +int placerLettre(char *motATrouver,char *motCourant,char lettrePropose); + +// retourne 0 si la lettre a deja ete propose ou si ce n'est pas une lettre +int verifierLettrePropose(char *lettresProposees, int nbLettreProposee, char lettre); + +// retourne un entier compris entre 0 et maxAlea +unsigned int aleatoire( unsigned int maxAlea ); + +// met des - dans chaque case du tableau motCourant +void initialiserMot(char *motCourant,int longueurMot); + +#endif diff --git a/BTS/C/Premiere annee/Pendu/main.c b/BTS/C/Premiere annee/Pendu/main.c new file mode 100644 index 0000000..e3bb967 --- /dev/null +++ b/BTS/C/Premiere annee/Pendu/main.c @@ -0,0 +1,65 @@ +#include "gestionPendu.h" + +int main(int argc, char *argv[]) +{ + char *listeMots[NBMOTS]={"bonjour","maison","noyau","temps","blond"}; + int cptErreur=0; + int longueurMot; + char *motATrouver; + char *motCourant; + int choix,i; + char lettre; + char histo[NB_MAX_LETTRES_POSSIBLE]; + int cptProposition=0; + int trouve; + do{ + choix=afficherMenu(); + // l'utilisateur veut jouer + if (choix>0){ + // init des compteurs + cptErreur=0; + cptProposition=0; + // tirage aleatooire du mot + motATrouver=listeMots[aleatoire(NBMOTS-1)]; + // init du motCourant + longueurMot=strlen(motATrouver); + motCourant=(char *)malloc(longueurMot+1); + initialiserMot(motCourant,longueurMot); + // boucle de jeu + do{ + printf("%s\n",motCourant); + afficherLettre(histo,cptProposition); + // demander/redemander une lettre tant que + // le caractere saisi n'est pas une lettre + // ou a deja ete propose + do{ + printf("donnez une lettre :"); + scanf(" %c",&lettre); + }while(verifierLettrePropose(histo,cptProposition,lettre)==0); + // mise a jour du tableau des lettres proposees + histo[cptProposition]=lettre; + cptProposition++; + // mise a jour du compteur d'erreur + cptErreur+=placerLettre(motATrouver,motCourant,lettre); + + afficherPendu(cptErreur); + trouve=motEstTrouve(motATrouver,motCourant); + }while(/* a completer*/); + // liberation de la memoire du mot courant + free(motCourant); + // affichage des messages de fin de jeu + if (trouve==0) + { + printf("bravo\n"); + } + else + { + printf("Perdu le mot etait %s\n",motATrouver); + } + } // fin boucle de jeu + + }while (choix!=-1); + + + return EXIT_SUCCESS; +} diff --git a/BTS/C/Premiere annee/PointeursMois/biblio.c b/BTS/C/Premiere annee/PointeursMois/biblio.c new file mode 100644 index 0000000..ba22024 --- /dev/null +++ b/BTS/C/Premiere annee/PointeursMois/biblio.c @@ -0,0 +1,152 @@ +#include +#include +#include +#include +#define NBMOIS 12 +#define TAILLEMAX 50 + +char* moisNom(int numeroMois){ + char *mois[NBMOIS] = {"Janvier", "Fevrier", "Mars", "Avril", "Mai", "Juin", "Juillet", "Aout", "Septembre", "Octobre", "Novembre", "Decembre"}; + char *moisRetour; + + numeroMois--; + + moisRetour = (char*)malloc( ( strlen(mois[numeroMois])+1) * sizeof(char)); + strcpy(moisRetour, mois[numeroMois]); + + return moisRetour; +} + +char* supprimerE(char chaine[]){ + int boucle; + int boucleSensE = 0; + int nbE = 0; + + char *sensE; + + for(boucle = 0; boucle < strlen(chaine); boucle++){ + if(chaine[boucle] == 'e'){ + nbE++; + } + } + + sensE = (char*)malloc( ( strlen(chaine)-nbE+1) * sizeof(char)); + + for(boucle = 0; boucle < strlen(chaine); boucle++){ + if(chaine[boucle] != 'e'){ + sensE[boucleSensE] = chaine[boucle]; + boucleSensE++; + } + } + + return sensE; +} + +char* saisirChaine(char *message){ + char *nom; + char buffer[TAILLEMAX]; + + printf("%s", message); + scanf("%s", buffer); + + nom = (char*) malloc((strlen(buffer)+1)*sizeof(char)); + strcpy(nom, buffer); + + return nom; + +} + +void swapFloat(float *ptr1, float *ptr2){ + float tmp; + + tmp = *ptr1; + *ptr1 = *ptr2; + *ptr2 = tmp; +} + +void discriminant(float a, float b, float c, float *racine1, float *racine2, int *printResult){ + int delta; + + delta = b*b - 4*a*c; + + if(delta >= 0){ + *racine1 = ((-b - sqrt(delta)) / (2*a)); + *racine2 = ((-b + sqrt(delta)) / (2*a)); + *printResult = 1; + } +} + +void exercice1(){ + int choix; + char *pointeur; + + printf("De quel mois voulez-vous le nom ? (Entre 1 et 12)\n"); + scanf("%d", &choix); + + pointeur = moisNom(choix); + + printf("%s", pointeur); +} + +void exercice2(){ + char chaine[TAILLEMAX]; + char *pointeur; + + printf("Saisissez une chaine de caractère :"); + scanf("%s", chaine); + + pointeur = supprimerE(chaine); + + printf("%s", pointeur); +} + +void exercice3(){ + char *nom; + nom = saisirChaine("Comment vous appelez-vous ?"); + printf("Vous vous appelez %s.\n", nom); +} + +void exercice4(){ + float val1; + float val2; + + printf("Saisissez deux réels.\n"); + printf("1: "); + scanf("%f", &val1); + printf("2: "); + scanf("%f", &val2); + + printf("Avant le changement:\n"); + printf("Val1 = %.2f \tVal2 = %.2f\n", val1, val2); + swapFloat(&val1, &val2); + + printf("Après le changement:\n"); + printf("Val1 = %.2f \tVal2 = %.2f", val1, val2); +} + +void exercice5(){ + float a; + float b; + float c; + + float racine1; + float racine2; + + int printResult = 0; + + printf("Calcul de discriminant.\n"); + printf("a: "); + scanf("%f", &a); + printf("b: "); + scanf("%f", &b); + printf("c: "); + scanf("%f", &c); + + discriminant(a, b, c, &racine1, &racine2, &printResult); + + if(printResult){ + printf("%f\t%f", racine1, racine2); + }else{ + printf("Aucune racine."); + } +} diff --git a/BTS/C/Premiere annee/PointeursMois/biblio.h b/BTS/C/Premiere annee/PointeursMois/biblio.h new file mode 100644 index 0000000..8205a0d --- /dev/null +++ b/BTS/C/Premiere annee/PointeursMois/biblio.h @@ -0,0 +1,24 @@ +#ifndef BIBLIO_H_INCLUDED +#define BIBLIO_H_INCLUDED + +char* moisNom(int numeroMois); + +char* supprimerE(char chaine[]); + +char* saisirChaine(char *message); + +void swapFloat(float *ptr1, float *ptr2); + +void discriminant(float a, float b, float c, float *racine1, float *racine2); + +void exercice1(); + +void exercice2(); + +void exercice3(); + +void exercice4(); + +void exercice5(); + +#endif // BIBLIO_H_INCLUDED diff --git a/BTS/C/Premiere annee/PointeursMois/main.c b/BTS/C/Premiere annee/PointeursMois/main.c new file mode 100644 index 0000000..f9412e1 --- /dev/null +++ b/BTS/C/Premiere annee/PointeursMois/main.c @@ -0,0 +1,41 @@ +#include +#include +#include "biblio.h" + +int main() +{ + int choixExercice; + + printf("Quel exercice voulez-vous essayer ?\n"); + printf("1- Adresse des mois\n"); + printf("2- Enlever le caractere e\n"); + printf("3- Nom et chaine de caractere\n"); + printf("4- Inversion de float\n"); + printf("5- Discriminant\n"); + printf("Votre choix : "); + + scanf("%d", &choixExercice); + + switch (choixExercice){ + case 1: + exercice1(); + break; + case 2: + exercice2(); + break; + case 3: + exercice3(); + break; + case 4: + exercice4(); + break; + case 5: + exercice5(); + break; + default: + break; + } + + + return 0; +} diff --git a/BTS/C/Premiere annee/TDFonction/biblioPerso.c b/BTS/C/Premiere annee/TDFonction/biblioPerso.c new file mode 100644 index 0000000..1c14d7b --- /dev/null +++ b/BTS/C/Premiere annee/TDFonction/biblioPerso.c @@ -0,0 +1,54 @@ + +#include +#include + +void afficherMenu(char sexe){ + if(sexe == 'f'){ + printf("Menu pour femme\n"); + } + if(sexe == 'h'){ + printf("Menu pour homme\n"); + } +} + +float additionReel(float v1, float v2){ + return v1+v2; +} + +void afficherCarrer(int v1){ + printf("%d", v1*v1); +} + +int calculerCarrer(int v1){ + return v1*v1; +} + +float calculerDiscriminant(float a, float b, float c){ + return b*b-4*a*c; +} + +void afficherRacines(float a, float b, float c){ + int delta = b*b-4*a*c; + if(delta > 0){ + printf("Il y a deux solutions.\n"); + printf("La première est %.2f.\n", (-b+(delta/delta))/(2*a)); + printf("La seconde est %.2f.\n", (-b-(delta/delta))/(2*a)); + } + if(delta == 0){ + printf("Il n'y a qu'une solution qui est %.2f.\n", -b/(2*a)); + } + if(delta < 0){ + printf("Le discriminant n'admet aucune solution.\n"); + } +} + +void afficherCarre(int cote){ + int boucleHor; + int boucleVer; + for(boucleVer = 0; boucleVer < cote; boucleVer++){ + for(boucleHor = 0; boucleHor < cote; boucleHor++){ + printf("*"); + } + printf("\n"); + } +} diff --git a/BTS/C/Premiere annee/TDFonction/biblioPerso.h b/BTS/C/Premiere annee/TDFonction/biblioPerso.h new file mode 100644 index 0000000..c6a9371 --- /dev/null +++ b/BTS/C/Premiere annee/TDFonction/biblioPerso.h @@ -0,0 +1,12 @@ +#ifndef BIBLIOPERSO_H_INCLUDED +#define BIBLIOPERSO_H_INCLUDED + +void afficherMenu(char sexe); +float additionReel(float v1, float v2); +void afficherCarrer(int v1); +int calculerCarrer(int v1); +float calculerDiscriminant(float a, float b, float c); +void afficherRacines(float a, float b, float c); +void afficherRectance(int cote); + +#endif // BIBLIOPERSO_H_INCLUDED diff --git a/BTS/C/Premiere annee/TDFonction/main.c b/BTS/C/Premiere annee/TDFonction/main.c new file mode 100644 index 0000000..5096b30 --- /dev/null +++ b/BTS/C/Premiere annee/TDFonction/main.c @@ -0,0 +1,59 @@ +#include +#include +#include "biblioPerso.h" + +int main() +{ + char sexe; + int valeurCarrer; + int coteCarre; + int coteRectLargeur; + int coteRectLongueur; + float valeurAddition1; + float valeurAddition2; + float a; + float b; + float c; + + printf("Bonjour.\n"); + printf("Votre sexe :"); + scanf("%c", &sexe); + + afficherMenu(sexe); + + printf("\nSaisissez une valeur :"); + scanf("%f", &valeurAddition1); + printf("Saisissez une seconde valeur :"); + scanf("%f", &valeurAddition2); + printf("Votre somme est égale à %.2f.\n", additionReel(valeurAddition1, valeurAddition2)); + + printf("\nSaisissez une valeur pour afficher un carré :"); + scanf("%d", &valeurCarrer); + afficherCarrer(valeurCarrer); + + printf("\n\nSaisissez une valeur pour calculer un carré :"); + scanf("%d", &valeurCarrer); + printf("Votre valeur calculée au carré donne %d.", calculerCarrer(valeurCarrer)); + + printf("\n\nNous voulons calculer un discriminant.\n"); + printf("Saisissez a :"); + scanf("%f", &a); + printf("Saisissez b :"); + scanf("%f", &b); + printf("Saisissez c :"); + scanf("%f", &c); + printf("Votre discriminant est %.2f.\n", calculerDiscriminant(a, b, c)); + afficherRacines(a, b, c); + + printf("\nNous voulons dessiner un carré.\n"); + printf("Saisissez la taille du côté :"); + scanf("%d", &cote); + afficherCarre(cote); + + printf("\nNous voulons dessiner un carré.\n"); + printf("Saisissez la taille du côté :"); + scanf("%d", &cote); + afficherCarre(cote); + + return 0; +} diff --git a/BTS/C/Premiere annee/TD_boucle.c b/BTS/C/Premiere annee/TD_boucle.c new file mode 100644 index 0000000..061dea9 --- /dev/null +++ b/BTS/C/Premiere annee/TD_boucle.c @@ -0,0 +1,26 @@ +#include +#include + +int main() +{ + float note; + + printf("Entrer la note obtenue :"); + scanf("%f", ¬e); + if(note >= 16){ + printf("Votre note est A.\n"); + }else{ + if(note >= 12){ + printf("Votre note est B.\n"); + }else{ + if(note >= 8){ + printf("Votre note est C.\n"); + }else{ + if(note >= 4){ + printf("Votre note est D.\n"); + }else{ + printf("Votre note est E.\n"); + }}}} + + return 0; +} diff --git a/BTS/C/Premiere annee/TP1.c b/BTS/C/Premiere annee/TP1.c new file mode 100644 index 0000000..633d082 --- /dev/null +++ b/BTS/C/Premiere annee/TP1.c @@ -0,0 +1,19 @@ +#include +#include +#define length 255 + +int main() +{ + + char chaineScan [length]; + char chaineGet [length]; + + + printf("Entrer chaine de caractère, test pour gets: "); + fgets(chaineGet, sizeof(chaineGet), stdin); + printf("La saisie retenue est: %s\n", chaineGet); + + printf("Entrer chaine de caractère, test pour scanf: "); + scanf("%s", chaineScan); + printf("La saisie retenue est: %s\n", chaineScan); +} diff --git a/BTS/C/Premiere annee/TP1_11.c b/BTS/C/Premiere annee/TP1_11.c new file mode 100644 index 0000000..f8ed194 --- /dev/null +++ b/BTS/C/Premiere annee/TP1_11.c @@ -0,0 +1,24 @@ +#include +#include + +int main() +{ + int nbValeur; + int tabValeur[255]; + int loop; + int plusGrosseValeur; + + printf("Combien de valeur avez-vous à comparer ?\n"); + scanf("%d", &nbValeur); + printf("\n"); + + for(loop = 1; nbValeur >= loop; loop++){ + printf("%d valeur: ", loop); + scanf("%d", &tabValeur[loop]); + if(plusGrosseValeur <= tabValeur[loop]){ + plusGrosseValeur = tabValeur[loop]; + } + } + printf("\nLa plus grosse valeur est %d.\n",plusGrosseValeur); + +} diff --git a/BTS/C/Premiere annee/TP1_13.c b/BTS/C/Premiere annee/TP1_13.c new file mode 100644 index 0000000..c4145a1 --- /dev/null +++ b/BTS/C/Premiere annee/TP1_13.c @@ -0,0 +1,13 @@ +#include +#include + +int main() +{ + char caractere; + + printf("Donner un caractère: "); + scanf("%s", &caractere); + printf("La valeur décimale est %d.\n", caractere); + printf("La valeur hexadécimale est 0x%x.\n", caractere); + +} diff --git a/BTS/C/Premiere annee/TP_17.c b/BTS/C/Premiere annee/TP_17.c new file mode 100644 index 0000000..83b4264 --- /dev/null +++ b/BTS/C/Premiere annee/TP_17.c @@ -0,0 +1,21 @@ +#include +#include + +int main() +{ + float a,b,c,resultat; + + printf("Dans l'ordre, entrer les valeurs de a, de b et de c pour l'équation ax²+bx+c=0.\n"); + scanf("%f", &a); + scanf("%f", &b); + scanf("%f", &c); + resultat = b * b - 4 * a * c; + if(resultat > 0){ + printf("L'équation admet 2 solutnios."); + }else if(resultat == 0){ + printf("L'équation admet une solution."); + }else{ + printf("L'équation n'admet aucune solution."); + } + +} diff --git a/BTS/C/Premiere annee/TP_PI.c b/BTS/C/Premiere annee/TP_PI.c new file mode 100644 index 0000000..3673467 --- /dev/null +++ b/BTS/C/Premiere annee/TP_PI.c @@ -0,0 +1,8 @@ +#include +#include + +int main() +{ + float pi = (4.0/1.0) - (4.0/3.0) + (4.0/5.0) - (4.0/7.0) + (4.0/9.0) - (4.0/11.0) + (4.0/13.0) - (4.0/15.0); + printf("%f", pi); +} diff --git a/BTS/C/Premiere annee/TP_boucle.c b/BTS/C/Premiere annee/TP_boucle.c new file mode 100644 index 0000000..e543c27 --- /dev/null +++ b/BTS/C/Premiere annee/TP_boucle.c @@ -0,0 +1,30 @@ +#include +#include + +int main() +{ + char note; + + printf("Entrer la note en minuscule:"); + scanf("%c", ¬e); + switch (note){ + case 'a': + printf("Votre note est entre 16 et 20.\n"); + break; + case 'b': + printf("Votre note est entre 12 et 16.\n"); + break; + case 'c': + printf("Votre note est entre 8 et 12.\n"); + break; + case 'd': + printf("Votre note est entre 4 et 8.\n"); + break; + case 'e': + printf("Votre note est entre 0 et 4.\n"); + break; + default: + printf("Vous n'avez pas entrer de valeur correcte.\n"); + } + +} diff --git a/BTS/C/Premiere annee/TP_boucle_if.c b/BTS/C/Premiere annee/TP_boucle_if.c new file mode 100644 index 0000000..b5358b9 --- /dev/null +++ b/BTS/C/Premiere annee/TP_boucle_if.c @@ -0,0 +1,30 @@ +#include +#include + +int main() +{ + char note; + + printf("Entrer la note en minuscule:"); + scanf("%c", ¬e); + if(note == 'a'){ + printf("Votre note est entre 16 et 20.\n"); + }else{ + if(note == 'b'){ + printf("Votre note est entre 12 et 16.\n"); + }else{ + if(note == 'c'){ + printf("Votre note est entre 8 et 12.\n"); + }else{ + if(note == 'd'){ + printf("Votre note est entre 4 et 8.\n"); + }else{ + if(note == 'e'){ printf("Votre note est entre 0 et 4.\n"); + } + } + } + } + } + + +} diff --git a/BTS/C/Premiere annee/TP_boucle_tableau7.c b/BTS/C/Premiere annee/TP_boucle_tableau7.c new file mode 100644 index 0000000..f21c12e --- /dev/null +++ b/BTS/C/Premiere annee/TP_boucle_tableau7.c @@ -0,0 +1,10 @@ +#include +#include + +int main() +{ + int var = 7, loop; + for(loop = 0; loop <= 10; loop++){ + printf("%d x 7 = %d\n", loop, loop*7); + } +} diff --git a/BTS/C/Premiere annee/TP_boucle_tableuser.c b/BTS/C/Premiere annee/TP_boucle_tableuser.c new file mode 100644 index 0000000..75f6dc1 --- /dev/null +++ b/BTS/C/Premiere annee/TP_boucle_tableuser.c @@ -0,0 +1,12 @@ +#include +#include + +int main() +{ + int var, loop; + printf("Le chiffre que vous voulez mutliplier est :"); + scanf("%d", &var); + for(loop = 0; loop <= 10; loop++){ + printf("%d x %d = %d\n", loop, var, loop*var); + } +} diff --git a/BTS/C/Premiere annee/TP_population.c b/BTS/C/Premiere annee/TP_population.c new file mode 100644 index 0000000..dfbeb48 --- /dev/null +++ b/BTS/C/Premiere annee/TP_population.c @@ -0,0 +1,24 @@ +#include +#include + +int main(int argc, char *argv[]) +{ + float taillePopulation1, taillePopulation2, annee=0; + float tauxPopulation1, tauxPopulation2; + printf("Entrer la taille de la population 1 :"); + scanf("%f", &taillePopulation1); + printf("Entrer la taille de la population 2 :"); + scanf("%f", &taillePopulation2); + printf("Entrer le taux de croissance de la population 1 par an en pourcent:"); + scanf("%f", &tauxPopulation1); + printf("Entrer le taux de croissance de la population 2 par an en pourcent:"); + scanf("%f", &tauxPopulation2); + while(taillePopulation2 <= taillePopulation1){ + annee++; + taillePopulation1 = taillePopulation1 * (tauxPopulation1/100+1); + taillePopulation2 = taillePopulation2 * (tauxPopulation2/100+1); + } + printf("La population 2 aura dépassé la population 1 au bout de %.0f année(s).", annee); + + return 0; +} diff --git a/BTS/C/Premiere annee/TP_somme.c b/BTS/C/Premiere annee/TP_somme.c new file mode 100644 index 0000000..c5b1222 --- /dev/null +++ b/BTS/C/Premiere annee/TP_somme.c @@ -0,0 +1,109 @@ +#include +#include + + + +int main() +{ + int boucle = 0; + while(!boucle){ + int numeroExercice; + printf("Quel exercice voulez vous essayez ?\n\n"); + printf("Exercice 1 : Addition\n"); + printf("Exercice 2 : Division\n"); + printf("Exercice 3 : Acquisition caractères\n\n"); + printf("Numéro de l'exercice demandé: "); + scanf("%d", &numeroExercice); + + if(numeroExercice == 1){ + + printf("\n\n"); + printf("EXERCICE 1\n\n\n"); + + float premier_entier; + float second_entier; + + printf("Premier chiffre: "); + scanf("%f", &premier_entier); + printf("Second chiffre: "); + scanf("%f", &second_entier); + printf("\n"); + float resultat = premier_entier + second_entier; + printf("La somme est %f.\n\n\n",resultat); + + printf("Voules-vous quitter le programme ?\n"); + printf("0 - Non\n"); + printf("1 - Oui\n"); + printf("Votre choix: "); + scanf("%d", &boucle); + + }else if(numeroExercice == 2){ + + printf("\n\n"); + printf("EXERCICE 2\n\n\n"); + + float divise; + float diviseur; + + printf("Chiffre à divisé: "); + scanf("%f", &divise); + printf("Chiffre diviseur: "); + scanf("%f", &diviseur); + printf("\n"); + if(diviseur != 0){ + + float resultat = divise / diviseur; + printf("La division de %f par %f est %f.\n\n\n" ,divise, diviseur, resultat); + + printf("Voules-vous quitter le programme ?\n"); + printf("0 - Non\n"); + printf("1 - Oui\n"); + printf("Votre choix: "); + scanf("%d", &boucle); + + }else{ + + printf("Le diviseur est nul, la division est donc impossible.\n\n"); + + printf("Voules-vous quitter le programme ?\n"); + printf("0 - Non\n"); + printf("1 - Oui\n"); + printf("Votre choix: "); + scanf("%d", &boucle); + } + + }else if(numeroExercice == 3){ + + printf("\n\n"); + printf("EXERCICE 3\n\n\n"); + + char nom [80]; + char prenom [80]; + + printf("Votre nom est: "); + scanf("%79s", nom); + printf("Votre prenom est: "); + scanf("%79s", prenom); + printf("\n"); + printf("Bonjour %s %s.\n\n\n" ,prenom, nom); + + printf("Voules-vous quitter le programme ?\n"); + printf("0 - Non\n"); + printf("1 - Oui\n"); + printf("Votre choix: "); + scanf("%d", &boucle); + + }else{ + printf("\n"); + printf("Il n'y a pas d'exercice %d.\n", numeroExercice); + printf("\n"); + + printf("Voules-vous quitter le programme ?\n"); + printf("0 - Non\n"); + printf("1 - Oui\n"); + printf("Votre choix: "); + scanf("%d", &boucle); + } + } + +} diff --git a/BTS/C/Premiere annee/TP_station_meteo.c b/BTS/C/Premiere annee/TP_station_meteo.c new file mode 100644 index 0000000..e4eb2ae --- /dev/null +++ b/BTS/C/Premiere annee/TP_station_meteo.c @@ -0,0 +1,45 @@ +#include +#include + +int main() +{ + float boolean = 1, lacune = 0, entree = 0; + float minimum = 0, maximum = 0, minimumBuffer = 0, maximumBuffer = 0; + do{ + printf("Entrer température minimum :"); + scanf("%f", &minimum); + printf("Entrer température maximum :"); + scanf("%f", &maximum); + + maximumBuffer = maximumBuffer + maximum; + minimumBuffer = minimumBuffer + minimum; + + if(minimum == 0 && maximum == 0) + { + boolean = 0; + } + else + { + if(minimum == 0 || maximum == 0) + { + lacune++; + entree++; + } + else + { + entree++; + } + } + }while(boolean == 1); + + if(entree != 0){ + printf("La moyenne des températures maximum est de %.2f.\n", maximumBuffer/entree); + printf("La moyenne des températures minimum est de %.2f.\n", minimumBuffer/entree); + printf("Il y a eu %.0f lacune(s).\n", lacune); + printf("Il y a eu %.0f entrée(s).\n", entree); + printf("Le nombre de lacune représente %.2f pourcent du nombre de données.", ((lacune/entree)/2)*100); + }else{ + printf("Vous devez entrer une valeur.\n"); + } + +} diff --git a/BTS/C/Premiere annee/TP_test_negatif.c b/BTS/C/Premiere annee/TP_test_negatif.c new file mode 100644 index 0000000..512b6c1 --- /dev/null +++ b/BTS/C/Premiere annee/TP_test_negatif.c @@ -0,0 +1,24 @@ +#include +#include + +int main() +{ + int var = 0; + int boolean = 0; + int varPositive = 0; + int somme = 0; + while(boolean == 0){ + printf("Entrer une valeur :"); + scanf("%d", &var); + if(var < 0){ + printf("Vous avez entré une valeure néfative.\n"); + boolean++; + }else{ + printf("Valeur correcte.\n"); + somme = somme + var; + varPositive++; + } + } + printf("Vous avez saisi %d valeurs positives et leur somme est de %d et la moyenne est de %f.\n", + varPositive, somme, somme/varPositive); +} diff --git a/BTS/C/Premiere annee/TP_triangle_isocele.c b/BTS/C/Premiere annee/TP_triangle_isocele.c new file mode 100644 index 0000000..c631af6 --- /dev/null +++ b/BTS/C/Premiere annee/TP_triangle_isocele.c @@ -0,0 +1,15 @@ +#include +#include + +int main() +{ + int cote, loopColonne, loopLigne; + printf("Le côté du triangle est de :"); + scanf("%d", &cote); + for(loopColonne=0; loopColonne < cote; loopColonne++){ + for(loopLigne=1; loopLigne <= cote-loopColonne; loopLigne++){ + printf("#"); + } + printf("\n"); + } +} diff --git a/BTS/C/Premiere annee/Vacances_1.c b/BTS/C/Premiere annee/Vacances_1.c new file mode 100644 index 0000000..882fb99 --- /dev/null +++ b/BTS/C/Premiere annee/Vacances_1.c @@ -0,0 +1,70 @@ +#include +#include + +int main() +{ + void affichageDate(int jour, int mois, int annee){ + int choix; + + do{ + printf("Format d'affichage de votre date de naissance :\n"); + printf("1 - jj/mm/aaaa\n"); + printf("2 - jj-mm-aaaa\n"); + printf("3 - jj:mm:aaaa\n"); + printf("4 - jj.mm.aaaa\n"); + printf("Choisissez le format d'affichage (1,2,3 ou 4) : "); + scanf("%d", &choix); + + switch (choix){ + case 1: + printf("Votre date de naissance est le %d/%d/%d.\n", jour, mois, annee); + break; + case 2: + printf("Votre date de naissance est le %d-%d-%d.\n", jour, mois, annee); + break; + case 3: + printf("Votre date de naissance est le %d:%d:%d.\n", jour, mois, annee); + break; + case 4: + printf("Votre date de naissance est le %d.%d.%d.\n", jour, mois, annee); + break; + default : + printf("Votre choix n'est pas correcte, réessayez.\n"); + } + }while(choix != 1 || choix != 2 || choix != 3 || choix != 4); + } + + int jour = 17; + int moisNum = 12; + int annee = 1991; + + char nom[50] = "Herbron"; + char prenom[50] = "Tanguy"; + + /*printf("Jour de naissance : "); + scanf("%d", &jour); + printf("Mois de naissance : "); + scanf("%d", &moisNum); + printf("Année de naissance : "); + scanf("%d", &annee); + printf("\n"); + + printf("Votre date de naissance est le %d/%d/%d.\n\n", jour, moisNum, annee); + + printf("Votre nom : "); + scanf("%s", nom); + printf("Votre prénom : "); + scanf("%s", prenom); + printf("\n");*/ + + printf("Bonjour %s %s.\n\n", prenom, nom); + + if(annee >= 1995){ + printf("Désolé, vous êtes trop jeune pour continuer."); + }else{ + printf("Vous êtes autorisé à continuer."); + affichageDate(jour, moisNum, annee); + } + + return 0; +} diff --git a/BTS/C/Premiere annee/accesFichier/biblio.c b/BTS/C/Premiere annee/accesFichier/biblio.c new file mode 100644 index 0000000..429aa3d --- /dev/null +++ b/BTS/C/Premiere annee/accesFichier/biblio.c @@ -0,0 +1,120 @@ +#include +#include +#include +#include +#include "biblio.h" + +void testErreur(){ + if(errno != NULL){ + printf("Erreur fichier : erreur n'%d\n", errno); + exit(0); + } +} + +void exercice1Et2(){ + int i; + int size; + int lettre = 0; + char car; + + FILE *pFich = fopen("/home/USERS/ELEVES/SNIR2015/fichierTexte1.txt", "r"); + + testErreur(); + + fseek(pFich, 0, 2); + size = ftell(pFich); + fseek(pFich, 0, SEEK_SET); + + for(i = 0; i < size; i++){ + car = fgetc(pFich); + printf("%c", car); + if('a' <= car && car <= 'z'){ + lettre++; + } + } + + printf("\n%d caracteres minuscules non accentués dans ce fichier.\n", lettre); +} + +void exercice3(){ + typePersonne personne; + FILE *pFich = fopen("personnes.txt", "w+"); + int i; + + testErreur(); + + for(i = 0; i < NBPERSONNE; i++){ + printf("Nouvelle personne :\n"); + printf("\tNom :"); + scanf("%s", personne.nom); + fprintf(pFich, "%s", personne.nom); + fprintf(pFich, "\n"); + printf("\tPrenom :"); + scanf("%s", personne.prenom); + fprintf(pFich, "%s", personne.prenom); + fprintf(pFich, "\n"); + printf("\tAge :"); + scanf("%d", &personne.age); + fprintf(pFich, "%d", personne.age); + fprintf(pFich, "\n"); + printf("\tPoids :"); + scanf("%.2f", &personne.poids); + fprintf(pFich, "%f", personne.poids); + fprintf(pFich, "\n"); + printf("\tSexe (m ou f) :"); + scanf(" %c", &personne.sexe); + fprintf(pFich, "%c", personne.sexe); + fprintf(pFich, "\n"); + } +} + +void exercice9(){ + FILE *pFich = fopen("/home/USERS/ELEVES/SNIR2015/adeneu/personne.txt", "r"); + typePersonne personneAxel; + + testErreur(); + + fscanf(pFich, "%s", personneAxel.nom); + fscanf(pFich, "%s", personneAxel.prenom); + fscanf(pFich, "%d", personneAxel.age); + + printf("%s\n", personneAxel.nom); + printf("%s\n", personneAxel.prenom); + printf("%d",personneAxel.age); + + +} + +void exercice3HautNiveau(){ + typePersonne personne; + FILE *pFich = fopen("personnes.b", "w+"); + int i; + + testErreur(); + + for(i = 0; i < NBPERSONNE; i++){ + printf("Nouvelle personne :\n"); + printf("\tNom :"); + scanf("%s", personne.nom); + fwrite(personne.nom, 50, 1, pFich); + fwrite("\n", 2, 1, pFich); + printf("\tPrenom :"); + scanf("%s", personne.prenom); + fwrite(personne.prenom, 50, 1, pFich); + fwrite("\n", 2, 1, pFich); + printf("\tAge :"); + scanf("%d", &personne.age); + fwrite(&personne.age, 4, 1, pFich); + fwrite("\n", 2, 1, pFich); + printf("\tPoids :"); + scanf("%.2f", &personne.poids); + fwrite(&personne.poids, 4, 1, pFich); + fwrite("\n", 2, 1, pFich); + printf("\tSexe (m ou f) :"); + scanf(" %c", &personne.sexe); + fwrite(&personne.sexe, 4, 1, pFich); + fwrite("\n", 2, 1, pFich); + } + + fcloseall(); +} diff --git a/BTS/C/Premiere annee/accesFichier/biblio.h b/BTS/C/Premiere annee/accesFichier/biblio.h new file mode 100644 index 0000000..122a38e --- /dev/null +++ b/BTS/C/Premiere annee/accesFichier/biblio.h @@ -0,0 +1,24 @@ +#ifndef BIBLIO_H_INCLUDED +#define BIBLIO_H_INCLUDED +#define NBMAXCAR 50 +#define NBPERSONNE 1 + +typedef struct personne{ + char nom[NBMAXCAR]; + char prenom[NBMAXCAR]; + int age; + float poids; + char sexe ; // 'f' ou 'm' +}typePersonne; + +void testErreur(); + +void exercice1Et2(); + +void exercice3(); + +void exercice9(); + +void exercice3HautNiveau(); + +#endif // BIBLIO_H_INCLUDED diff --git a/BTS/C/Premiere annee/accesFichier/main.c b/BTS/C/Premiere annee/accesFichier/main.c new file mode 100644 index 0000000..aaaed4f --- /dev/null +++ b/BTS/C/Premiere annee/accesFichier/main.c @@ -0,0 +1,33 @@ +#include +#include +#include "biblio.h" + +int main(int argc, char *argv[]) +{ + int choix; + + printf("Quel exercice voulez-vous essayer ?\n"); + printf("1 - Print fichierTexte.txt et contage caracteres\n"); + printf("2 - Création d'adherents bas niveau\n"); + printf("3 - Création d'adherents haut niveau\n"); + printf("4 - Lecture txt voisin\n"); + printf("Votre choix : "); + scanf("%d", &choix); + + switch(choix){ + case 1: + exercice1Et2(); + break; + case 2: + exercice3(); + break; + case 3: + exercice3HautNiveau(); + break; + case 4: + exercice9(); + break; + } + + return 0; +} diff --git a/BTS/C/Premiere annee/argument1.c b/BTS/C/Premiere annee/argument1.c new file mode 100644 index 0000000..4e594ef --- /dev/null +++ b/BTS/C/Premiere annee/argument1.c @@ -0,0 +1,37 @@ +#include +#include +#include + +int main(int argc, char *argv[]) +{ + float val1, val2; + char car1; + + if(argc < 4){ + exit(0); + } + + sscanf(argv[1], "%c", &car1); + sscanf(argv[2], "%f", &val1); + sscanf(argv[3], "%f", &val2); + + switch (car1){ + case '+': + printf("%f\n", val1 + val2); + break; + case '*': + printf("%f\n", val1 * val2); + break; + case '/': + printf("%f\n", val1 / val2); + break; + case '-': + printf("%f\n", val1 - val2); + break; + default: + printf("Non\n"); + break; + } + + return 0; +} diff --git a/BTS/C/Premiere annee/caveHunter/caveHunter.c b/BTS/C/Premiere annee/caveHunter/caveHunter.c new file mode 100755 index 0000000..1228467 --- /dev/null +++ b/BTS/C/Premiere annee/caveHunter/caveHunter.c @@ -0,0 +1,366 @@ +/*************************************************************************** +caveHunter.c + ***************************************************************************/ +#include "caveHunter.h" +#include +#include +#include + + + +// attendre un maxTime millisecondes +void msleep(unsigned int maxTime) +{ + /* + struct timespec { + time_t tv_sec; // secondes + long tv_nsec; // nanosecondes + }; + */ + struct timespec req; + struct timespec rem; + time_t secondes=0; + long nanoSecondes=0; + if (maxTime>=1000) + { + do + { + secondes++; + maxTime-=1000; + } + while(maxTime>=1000); + } + nanoSecondes=maxTime*1000000; + req.tv_sec=secondes; + req.tv_nsec=nanoSecondes; + nanosleep(&req,&rem); + +} + +void initPiege( char tab[LARGEUR][HAUTEUR], int nbPiege ) +{ + + int x, y, i; + + for ( i = 0; i < nbPiege; i++ ) + { + do + { + x = aleatoire( LARGEUR ); + y = aleatoire( HAUTEUR ); + } + while ( tab[x][y] != 0 ); + + tab[x][y] = PIEGE; + } +} + +void initMonstre( char tab[LARGEUR][HAUTEUR], int nbMonstre ) +{ + + int x, y, i; + + for(i = 0; i < nbMonstre; i++){ + do{ + x = aleatoire(LARGEUR); + y = aleatoire(HAUTEUR); + }while(tab[x][y] != 0); + + tab[x][y] = MONSTRE; + } + +} + +void initPotion( char tab[LARGEUR][HAUTEUR], int nbPotion ) +{ + + int x, y, i; + + for(i = 0; i < nbPotion; i++){ + do{ + x = aleatoire(LARGEUR); + y = aleatoire(HAUTEUR); + }while(tab[x][y] != 0); + + tab[x][y] = POTION; + } + +} + +void initSortie(char tab[LARGEUR][HAUTEUR]) +{ + + int x, y; + + x = aleatoire(LARGEUR); + y = aleatoire(HAUTEUR); + + tab[x][y] = SORTIE; + +} + +void initMonde( char tab[LARGEUR][HAUTEUR], int nbMonstre, int nbPotion, int nbPiege ) +{ + int x, y; + printf("veuillez patientez, creation du monde...\n"); + + for ( x = 0; x < LARGEUR; x++ ) + { + for ( y = 0; y < HAUTEUR; y++ ) + { + tab[x][y] = 0; + } + } + + // placer tresor + x = aleatoire( LARGEUR ); + + y = aleatoire( HAUTEUR ); + + tab[x][y] = TRESOR; + + + + initPotion( tab, nbPotion ); + + initMonstre( tab, nbMonstre ); + + initPiege( tab, nbPiege ); + + initSortie(tab); + +} + +void afficheMonde( char tab[LARGEUR][HAUTEUR], int posX, int posY ) +{ + int x, y, cadre, i; +// afficher haut du cadre + + for(i = 0; i <= LARGEUR+1; i++){ + printf("*"); + } + + printf("\n"); + +//afficher les bords du cadre et l'aire de jeu + for ( y = HAUTEUR - 1; y >= 0; y-- ) + { + // bord gauche + printf( "*" ); + // aire de jeu + for ( x = 0; x < LARGEUR; x++ ) + { + + // afficher un . pour representer l'aire de jeu + + // afficher une X si x,y sont la position du joueur + + if(x == posX && y == posY){ + printf("X"); + }else{ + printf("."); + } + + } + // bord droit + printf( "*" ); + + printf( "\n" ); + } +// afficher bas du cadre + + for(i = 0; i <= LARGEUR+1; i++){ + printf("*"); + } + + printf("\n"); + +// afficher les coordonnees du joueur + printf( "pos(%d,%d) ", posX, posY ); + +} + + +//retourne une valeur entiere E[0..maxAlea[ +unsigned int aleatoire( unsigned int maxAlea ) +{ + /* struct timeb { + time_t time; + unsigned short millitm; + short timezone; + short dstflag; + };*/ + + struct timeb t; + //long t; + float a, b ; + unsigned int nbmilli; + ftime( &t ); + nbmilli = t.time * 1000 + t.millitm; + srand( nbmilli ); + a = rand(); + b = ( maxAlea * a ) / RAND_MAX; + //printf( "in alea %i\n", nbmilli ); + msleep(100); + return( ( unsigned int )b ); + + +} + +unsigned int getXTresor( char tab[LARGEUR][HAUTEUR] ) +{ + int x = 0, y; + int retour = -1; + + do + { + y = 0; + + do + { + if ( ( tab[x][y] ) == TRESOR ) + { + retour = x; + } + + y++; + } + while ( y < HAUTEUR && retour == -1 ); + + x++; + } + while ( x < LARGEUR && retour == -1 ); + + return retour; + +} + +unsigned int getYTresor( char tab[LARGEUR][HAUTEUR] ) +{ + int x, y=0; + int retour = -1; + + do + { + x = 0; + + do + { + if ( ( tab[x][y] ) == TRESOR ) + { + retour = y; + } + + x++; + } + while ( x < LARGEUR && retour == -1 ); + + y++; + } + while ( y < HAUTEUR && retour == -1 ); + + return retour; +} + + +unsigned int getXSortie( char tab[LARGEUR][HAUTEUR] ) +{ + int x = 0, y; + int retour = -1; + + do + { + y = 0; + + do + { + if ( ( tab[x][y] ) == SORTIE ) + { + retour = x; + } + + y++; + } + while ( y < HAUTEUR && retour == -1 ); + + x++; + } + while ( x < LARGEUR && retour == -1 ); + + return retour; + +} + +unsigned int getYSortie( char tab[LARGEUR][HAUTEUR] ) +{ + int x, y=0; + int retour = -1; + + do + { + x = 0; + + do + { + if ( ( tab[x][y] ) == SORTIE ) + { + retour = y; + } + + x++; + } + while ( x < LARGEUR && retour == -1 ); + + y++; + } + while ( y < HAUTEUR && retour == -1 ); + + return retour; +} + + +float getDistance( unsigned int xt, unsigned int yt, unsigned int xp, unsigned int yp ) +{ + int xVecteur=xt-xp; + int yVecteur=yt-yp; + float module; + module=sqrt((xVecteur*xVecteur+yVecteur*yVecteur)); + return module; +} + +void afficheTresor() +{ + + printf(" _______ _____ ______ _____ ____ _____ \n |__ __| __ \\| ____|/ ____|/ __ \\| __ \\ \n | | | |__) | |__ | (___ | | | | |__) |\n | | | _ /| __| \\___ \\| | | | _ / \n | | | | \\ \\| |____ ____) | |__| | | \\ \\ \n |_| |_| \\_\\______|_____/ \\____/|_| \\_\\\n"); + +} +void afficheMonstre() +{ + + printf(" __ __ ____ _ _ _____ _______ _____ ______ \n | \\/ |/ __ \\| \\ | |/ ____|__ __| __ \\| ____|\n | \\ / | | | | \\| | (___ | | | |__) | |__ \n | |\\/| | | | | . ` |\\___ \\ | | | _ /| __| \n | | | | |__| | |\\ |____) | | | | | \\ \\| |____ \n |_| |_|\\____/|_| \\_|_____/ |_| |_| \\_\\______|\n"); + +} +void affichePotion() +{ + + printf(" _____ _ _ _ _ \n | __ \\ | | (_) | | (_) \n | |__) |__ | |_ _ ___ _ __ __| | ___ ___ ___ _ _ __ \n | ___/ _ \\| __| |/ _ \\| '_ \\ / _` |/ _ \\ / __|/ _ \\| | '_ \\ \n | | | (_) | |_| | (_) | | | | | (_| | __/ \\__ \\ (_) | | | | |\n |_| \\___/ \\__|_|\\___/|_| |_| \\__,_|\\___| |___/\\___/|_|_| |_|\n"); + +} +void affichePiege() +{ + + printf(" _ \n (_) \n ___ _ _ _ __ ___ _ _ _ __ _ __ _ ___ __ _ ___ \n / _ \\| | | | '_ \\/ __| | | | | '_ \\ | '_ \\| |/ _ \\/ _` |/ _ \\\n | (_) | |_| | |_) \\__ \\_ | |_| | | | | | |_) | | __/ (_| | __/\n \\___/ \\__,_| .__/|___( ) \\__,_|_| |_| | .__/|_|\\___|\\__, |\\___|\n | | |/ | | __/ | \n |_| |_| |___/ \n"); + +} +void afficheSortie() +{ + + printf(" ________ _______ _______ \n | ____\\ \\ / /_ _|__ __|\n | |__ \\ V / | | | | \n | __| > < | | | | \n | |____ / . \\ _| |_ | | \n |______/_/ \\_\\_____| |_| \n"); + +} +void affichePerdu() +{ + printf(" (\\ _ /)\n ( \\ O / )\n (// \\\\)\n X\n / \\\n /___\\\n _____/ \\\\_____\n | ||\n | ||\n | ||\n | _ ___ _ ||\n | | \\ | | \\ ||\n | | | | | | ||\n | |_/ | |_/ ||\n | | \\ | | ||\n | | \\ | | ||\n | | \\. _|_. | . ||\n | ||\n * * | * ** * ** |** **\n "); + +} + diff --git a/BTS/C/Premiere annee/caveHunter/caveHunter.h b/BTS/C/Premiere annee/caveHunter/caveHunter.h new file mode 100755 index 0000000..0c76b9e --- /dev/null +++ b/BTS/C/Premiere annee/caveHunter/caveHunter.h @@ -0,0 +1,38 @@ +/*************************************************************************** +caveHunter.h + ***************************************************************************/ +#ifndef TRESOR_H +#define TRESOR_H +#include +#include +#include + +#define LARGEUR 20 +#define HAUTEUR 10 + +#define TRESOR 4 +#define SORTIE 5 +#define PIEGE 2 +#define MONSTRE 1 +#define POTION 3 +#define VIE 4 + +void initMonde( char tab[LARGEUR][HAUTEUR], int nbMonstre, int nbPotion, int nbPiege ); +unsigned int aleatoire(unsigned int maxAlea); +void initPiege( char tab[LARGEUR][HAUTEUR], int nbPiege ); +void initMonstre( char tab[LARGEUR][HAUTEUR], int nbMonstre ); +void initPotion( char tab[LARGEUR][HAUTEUR], int nbPotion ); +void afficheMonde( char tab[LARGEUR][HAUTEUR] , int posX, int posY ); +unsigned int getXTresor(char tab[LARGEUR][HAUTEUR]); +unsigned int getYTresor(char tab[LARGEUR][HAUTEUR]); +unsigned int getXSortie(char tab[LARGEUR][HAUTEUR]); +unsigned int getYSortie(char tab[LARGEUR][HAUTEUR]); +void afficheTresor(); +void afficheMonstre(); +void affichePotion(); +void affichePiege(); +void afficheSortie(); +void affichePerdu(); +float getDistance(unsigned int xt,unsigned int yt,unsigned int xp,unsigned int yp); + +#endif diff --git a/BTS/C/Premiere annee/caveHunter/main.c b/BTS/C/Premiere annee/caveHunter/main.c new file mode 100644 index 0000000..04da2dc --- /dev/null +++ b/BTS/C/Premiere annee/caveHunter/main.c @@ -0,0 +1,167 @@ +#include "caveHunter.h" + +int main( int argc, char *argv[] ) +{ + + char monde[LARGEUR][HAUTEUR]; + int i; + int x, y; + int sortie = 1; + int tresor = 0; + int vie ; + unsigned char dir; + char choix; + + do + { + initMonde(monde,10,2,5); // 10 monstres, 2 potions et 5 pieges + x = LARGEUR / 2; + y = HAUTEUR / 2; + sortie = 1; + tresor = 0; + vie = VIE; + + do + { + afficheMonde( monde, x, y ); + printf( " Vie[%d] ", vie ); + + + + if ( tresor == 0 ) + { + printf( "(tresor a %.1f m)\n", getDistance( x, y, getXTresor( monde ), getYTresor( monde ) ) ); + } + else + { + printf( "(sortie a %.1f m)\n", getDistance( x, y, getXSortie( monde ), getYSortie( monde ) ) ); + } + printf( "direction : " ); + scanf( " %c", &dir ); + + switch ( dir ) + { + + case '7': + x--; + y++; + break; + + case '8': + y++; + break; + + case '9': + x++; + y++; + break; + + case '4': + x--; + break; + + case '6': + x++; + break; + + case '1': + x--; + y--; + break; + + case '2': + y--; + break; + + case '3': + x++; + y--; + break; + } + + if ( x == LARGEUR ) + { + x = LARGEUR - 1; + } + + if ( x == -1 ) + { + x = 0; + } + + + if ( y == HAUTEUR ) + { + y = HAUTEUR - 1; + } + + if ( y == -1 ) + { + y = 0; + } + + switch ( monde[x][y] ) + { + + case MONSTRE: + vie -= MONSTRE; + afficheMonstre(); + printf( "un monstre!!! vous perdez %d pv\n", MONSTRE ); + break; + + case PIEGE: + vie -= PIEGE; + affichePiege(); + printf("arg, un piege!!! %d pv en moins\n", PIEGE); + break; + + case POTION: + vie += POTION; + affichePotion(); + printf("une potion de soin! %d pv en plus\n", POTION); + break; + + case SORTIE: + + if ( tresor == 1 ) + { + sortie = 0; + } + + afficheSortie(); + printf( "La sortie\n" ); + + break; + + case TRESOR: + tresor = 1; + afficheTresor(); + printf( "vous avez trouve le tresor. reste a trouver la sortie\n" ); + + break; + } + + if ( vie <= 0 ) + { + sortie = 0; + } + } + while ( sortie == 1 ); + + if ( vie <= 0 ) + { + affichePerdu(); + printf( "vous avez perdu\n" ); + } + else + { + printf( "congratulation!!\n" ); + } + printf("\nUne autre partie (O/N)?"); + scanf(" %c",&choix); + } + while (choix=='o' || choix=='O'); + + return EXIT_SUCCESS; + +} diff --git a/BTS/C/Premiere annee/cercle/cercle.c b/BTS/C/Premiere annee/cercle/cercle.c new file mode 100644 index 0000000..52a5a4a --- /dev/null +++ b/BTS/C/Premiere annee/cercle/cercle.c @@ -0,0 +1,45 @@ +/********************************************************************* +Nom du projet : cercle +Nom du fichier : cercle.c +*********************************************************************/ +#include "cercle.h" +#include +#include + +typeCercle *creerCercle(double xx, double yy, double rr) +{ + typeCercle *c; + c=(typeCercle *)malloc(sizeof(typeCercle)); + c->rayon=rr; + c->x=xx; + c->y=yy; + return c; +} + +void deplacerCercle(double nouveauX, double nouveauY, typeCercle *ptrCercle) +{ + ptrCercle->x=nouveauX; + ptrCercle->y=nouveauY; +} + +void changerRayonCercle(double nouveauRayon, typeCercle *ptrCercle) +{ + ptrCercle->rayon=nouveauRayon; +} + +void afficherCercle(typeCercle *ptrCercle) +{ + printf("x : %.2f\n",ptrCercle->x); + printf("y : %.2f\n",ptrCercle->y); + printf("rayon : %.2f\n\n",ptrCercle->rayon); +} + +float calculerPerimetre(typeCercle *ptrCercle) +{ + float perimetreCercle = 0; + + perimetreCercle = 2 * M_PI * ptrCercle->rayon; + + return perimetreCercle; +} + diff --git a/BTS/C/Premiere annee/cercle/cercle.h b/BTS/C/Premiere annee/cercle/cercle.h new file mode 100644 index 0000000..8cc1987 --- /dev/null +++ b/BTS/C/Premiere annee/cercle/cercle.h @@ -0,0 +1,18 @@ +#ifndef CERCLE_H_INCLUDED +#define CERCLE_H_INCLUDED +#include + +typedef struct { + double x; + double y; + double rayon; +}typeCercle; + +typeCercle *creerCercle(double xx, double yy, double rr); +void deplacerCercle(double nouveauX, double nouveauY, typeCercle *ptrCercle); +void changerRayonCercle(double nouveauRayon, typeCercle *ptrCercle); +void afficherCercle(typeCercle *ptrCercle); +float calculerPerimetre(typeCercle *ptrCercle); + + +#endif // CERCLE_H_INCLUDED diff --git a/BTS/C/Premiere annee/cercle/main.c b/BTS/C/Premiere annee/cercle/main.c new file mode 100644 index 0000000..1641658 --- /dev/null +++ b/BTS/C/Premiere annee/cercle/main.c @@ -0,0 +1,23 @@ +#include +#include +#include "cercle.h" + +int main() +{ + typeCercle *c1; + typeCercle *c2; + c1=creerCercle(3,5,10); // un cercle en (3,5) rayon 10 + c2=creerCercle(-2,4,3); // un cercle en (-2,4) rayon 3 + afficherCercle(c1); + printf("Le périmètre de C1 = %f\n", calculerPerimetre(c1)); + afficherCercle(c2); + printf("Le périmètre de C2 = %f\n", calculerPerimetre(c2)); + deplacerCercle(1,2,c1); // le cercle c1 est a present en (1,2) + afficherCercle(c1); + printf("Le périmètre de C1 = %f\n", calculerPerimetre(c1)); + changerRayonCercle(6,c2); // le cercle c2 a un nouveau rayon de 6 + afficherCercle(c2); + printf("Le périmètre de C2 = %f\n", calculerPerimetre(c2)); + + return 0; +} diff --git a/BTS/C/Premiere annee/conversionRLE/biblio.c b/BTS/C/Premiere annee/conversionRLE/biblio.c new file mode 100644 index 0000000..b26723e --- /dev/null +++ b/BTS/C/Premiere annee/conversionRLE/biblio.c @@ -0,0 +1,149 @@ +#include "biblio.h" + +void testErreur(int retour, int valeurCorrecte, char messageErreur[]) +{ + if(retour != valeurCorrecte) + { + + printf("Erreur lors de : %s.%d\n", messageErreur, errno); + exit(0); + } +} + +void decompressBMP(char fichierCompresse[], char fichierGenere[]) +{ + int i; + + enTeteFichierBMP enTeteFichier; + enTeteImageBMP enTeteImage; + rle couple; + couleur palette[NBCOULEURS]; + + FILE *imageCompress = fopen(fichierCompresse, "r"); + FILE *imageGenere = fopen(fichierGenere, "w+"); + + if(imageCompress == NULL){ + printf("Impossible car le premier fichier est invalide.\n"); + exit(0); + } + if(imageGenere == NULL){ + printf("Impossible car le second fichier est invalide.\n"); + exit(0); + } + + testErreur(fread(&enTeteFichier, sizeof(enTeteFichier), 1, imageCompress), 1, "copie enTeteFichier"); + testErreur(fwrite(&enTeteFichier, sizeof(enTeteFichier), 1, imageGenere), 1, "ecriture enTeteFichier"); + testErreur(fread(&enTeteImage, sizeof(enTeteImage), 1, imageCompress), 1, "copie enTeteImage"); + enTeteImage.typeCompression = 0; + testErreur(fwrite(&enTeteImage, sizeof(enTeteImage), 1, imageGenere), 1, "ecriture enTeteImage"); + testErreur(fread(palette, sizeof(couleur), NBCOULEURS, imageCompress), NBCOULEURS, "copie palette"); + testErreur(fwrite(palette, sizeof(couleur), NBCOULEURS, imageGenere), NBCOULEURS, "ecriture palette"); + + while(fread(&couple, sizeof(rle), 1, imageCompress) == 1) + { + for(i = 0; i < couple.repetition; i++) + { + testErreur(fwrite(&couple.valCouleur, sizeof(char), 1, imageGenere), 1, "ecriture valCouleur"); + } + } + + fclose(imageCompress); + fclose(imageGenere); +} + +void compresBMP(char fichierDecompresse[], char fichierGenere[]) +{ + char valOctet; + char octetSuivant; + unsigned int ligne; + short int compteur; + char finLigne = 0; + + enTeteFichierBMP enTeteFichier; + enTeteImageBMP enTeteImage; + couleur palette[NBCOULEURS]; + + FILE *imageDecompress = fopen(("%s%s", fichierDecompresse, ".bmp"), "r"); + FILE *imageGenere = fopen(fichierGenere, "w+"); + + if(imageDecompress == NULL){ + printf("Impossible car le premier fichier est invalide.\n"); + exit(0); + } + if(imageGenere == NULL){ + printf("Impossible car le second fichier est invalide.\n"); + exit(0); + } + + testErreur(fread(&enTeteFichier, sizeof(enTeteFichier), 1, imageDecompress), 1, "copie enTeteFichier"); + testErreur(fwrite(&enTeteFichier, sizeof(enTeteFichier), 1, imageGenere), 1, "ecriture enTeteFichier"); + testErreur(fread(&enTeteImage, sizeof(enTeteImage), 1, imageDecompress), 1, "copie enTeteImage"); + enTeteImage.typeCompression = 1; + testErreur(fwrite(&enTeteImage, sizeof(enTeteImage), 1, imageGenere), 1, "ecriture enTeteImage"); + testErreur(fread(palette, sizeof(couleur), NBCOULEURS, imageDecompress), NBCOULEURS, "copie palette"); + testErreur(fwrite(palette, sizeof(couleur), NBCOULEURS, imageGenere), NBCOULEURS, "ecriture palette"); + + testErreur(fread(&valOctet, sizeof(char), 1, imageDecompress), 1, "premier valOctet"); + compteur = 0; + ligne = 0; + + while(fread(&octetSuivant, sizeof(char), 1, imageDecompress) == 1) + { + if(valOctet == octetSuivant && compteur < 255 && ligne < enTeteImage.largeur) + { + compteur++; + ligne++; + } + else + { + testErreur(fwrite(&compteur, sizeof(char), 1, imageGenere), 1, "ecriture compteur"); + testErreur(fwrite(&valOctet, sizeof(char), 1, imageGenere), 1, "ecriture valOctet"); + + compteur = 0; + valOctet = octetSuivant; + + if(ligne >= enTeteImage.largeur) + { + testErreur(fwrite(&finLigne, sizeof(char), 1, imageGenere), 1, "ecriture retourLigne"); + testErreur(fwrite(&finLigne, sizeof(char), 1, imageGenere), 1, "ecriture retourLigne"); + ligne = 0; + } + + } + } + + testErreur(fwrite("0", sizeof(char), 1, imageGenere), 1, "ecriture finFichier"); + testErreur(fwrite("1", sizeof(char), 1, imageGenere), 1, "ecriture finFichier"); + + fclose(imageDecompress); + fclose(imageGenere); +} + +void compressBMP(char fichierDecompresse[], char fichierGenere[]) +{ + char octet; + char ch; + + char* nomfichier = "RLE.bmp"; + strcat(fichierDecompresse, nomfichier); + + FILE *imageDecompress = fopen(fichierDecompresse, "r"); + FILE *imageGenere = fopen(fichierGenere, "w+"); + + if(imageDecompress == NULL){ + printf("Impossible car le premier fichier est invalide. %s\n", fichierDecompresse); + exit(0); + } + if(imageGenere == NULL){ + printf("Impossible car le second fichier est invalide.\n"); + exit(0); + } + + while(fread(&octet, sizeof(char), 1, imageDecompress) == 1) + { + testErreur(fwrite(&octet, sizeof(char), 1, imageGenere), 1, "ecriture compteur"); + } + + fclose(imageDecompress); + fclose(imageGenere); +} diff --git a/BTS/C/Premiere annee/conversionRLE/biblio.h b/BTS/C/Premiere annee/conversionRLE/biblio.h new file mode 100644 index 0000000..45a2bd7 --- /dev/null +++ b/BTS/C/Premiere annee/conversionRLE/biblio.h @@ -0,0 +1,52 @@ +#ifndef BIBLIO_H_INCLUDED +#define BIBLIO_H_INCLUDED + +#include +#include +#include + +#define NBCOULEURS 256 +#define TAILLEMAX 50 + +#pragma pack(push, 1) + +typedef struct +{ + unsigned char repetition; + unsigned char valCouleur; +}rle; + +typedef struct +{ + unsigned char signature[2]; + unsigned int tailleFichier; + unsigned int reserve; + unsigned int adresseRelative; + +}enTeteFichierBMP; + +typedef struct +{ + unsigned int tailleEnTete; + unsigned int largeur; + unsigned int hauteur; + unsigned short nbPlan; + unsigned short bitParPixel; + unsigned int typeCompression; + unsigned int tailleImage; + unsigned int resoHorizontale; + unsigned int resoVerticale; + unsigned int nbCouleursUtilisees; + unsigned int nbCouleursImportantes; + +}enTeteImageBMP; + +typedef struct +{ + unsigned char bleu; + unsigned char vert; + unsigned char rouge; + unsigned char alpha; +}couleur; + +#endif // BIBLIO_H_INCLUDED diff --git a/BTS/C/Premiere annee/conversionRLE/main.c b/BTS/C/Premiere annee/conversionRLE/main.c new file mode 100644 index 0000000..deadf09 --- /dev/null +++ b/BTS/C/Premiere annee/conversionRLE/main.c @@ -0,0 +1,17 @@ +#include "biblio.h" + +int main(int argc, char *argv[]) +{ + if(argc == 4) + { + if(strcmp(argv[1], "d") == 0) + { + decompressBMP(argv[2], argv[3]); + } + + if(strcmp(argv[1], "c") == 0) + { + compressBMP(argv[2], argv[3]); + } + } +} diff --git a/BTS/C/Premiere annee/exoVacances.c b/BTS/C/Premiere annee/exoVacances.c new file mode 100644 index 0000000..0daf424 --- /dev/null +++ b/BTS/C/Premiere annee/exoVacances.c @@ -0,0 +1,400 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define TAILLEMAX 50 + +void formatageDate(int jour, int mois, int annee){ + int choixFormatage; + do{ + printf("Format d'affichage de votre date de naissance : \n"); + printf("1 - jj/mm/aaaa\n"); + printf("2 - jj-mm-aaaa\n"); + printf("3 - jj:mm:aaaa\n"); + printf("4 - jj.mm.aaaa\n"); + printf("Choisissez le format d'affichage (1, 2, 3 ou 4) : "); + scanf("%d", &choixFormatage); + switch (choixFormatage){ + case 1: + printf("Votre date de naissance est le %d/%d/%d.\n\n", jour, mois, annee); + break; + case 2: + printf("Votre date de naissance est le %d-%d-%d.\n\n", jour, mois, annee); + break; + case 3: + printf("Votre date de naissance est le %d:%d:%d.\n\n", jour, mois, annee); + break; + case 4: + printf("Votre date de naissance est le %d.%d.%d.\n\n", jour, mois, annee); + break; + default: + printf("La valeur entrée est incorrecte, réessayez.\n"); + } + }while(choixFormatage < 1 || choixFormatage > 4); +} + +int acquisitionJourNaissance(){ + int jour; + do{ + printf("Jour de naissance : "); + scanf("%d", &jour); + }while(jour < 1 || jour > 31); + printf("Jour correcte.\n"); + return jour; +} + +int acquisitionMoisNaissance(){ + int mois; + do{ + printf("Mois de naissance : "); + scanf("%d", &mois); + }while(mois < 1 || mois > 12); + printf("Mois correcte.\n"); + return mois; +} + +int acquisitionAnneeNaissance(){ + int annee; + do{ + printf("Année de naissance : "); + scanf("%d", &annee); + }while(annee < 1900 || annee > 2013); + printf("Année correcte.\n"); + return annee; +} + +void comptageMois(int jour, int mois, int annee, int tabJourMois[]){ + int deroulementMois; + int nbMoisPlus30 = 0; + + for(deroulementMois = 0; deroulementMois < 12; deroulementMois++){ + printf("Le mois numéro %d contient %d jours.\n", deroulementMois+1, tabJourMois[deroulementMois]); + if(tabJourMois[deroulementMois] > 30){ + nbMoisPlus30++; + } + } + printf("Il y a %d mois ayant plus de 30 jours dans l'année.\n\n", nbMoisPlus30); +} + +void verificationDateNaissance(int jour, int mois, int tabJourMois[]){ + if(jour <= tabJourMois[mois-1]){ + printf("Votre date de naissance semble correcte car le mois numéro %d ne possède que %d jours.\n\n", mois, tabJourMois[mois-1]); + }else{ + printf("Votre date de naissance est impossible car le mois numéro %d ne possède que %d jours.\n\n", mois, tabJourMois[mois-1]); + } +} + +void affichageNomMois(int jour, int mois, int annee){ + char tabNomMois[12][10] = {"Janvier", "Février", "Mars", "Avril", "Mais", "Juin", "Juillet", "Aout", "Septembre", "Octobre", "Novembre", "Décembre"}; + int deroulementMois; + + for(deroulementMois = 0; deroulementMois < 12; deroulementMois++){ + printf("Le mois numéro %d a pour nom %s.\n", deroulementMois+1, tabNomMois[deroulementMois]); + } + printf("\n"); + printf("Votre date de naissance est le %d %s %d.\n", jour, tabNomMois[mois - 1], annee); +} + +void msleep(unsigned int maxTime){ + struct timespec req; + struct timespec rem; + timer_t secondes = 0; + long nanoSecondes = 0; + if(maxTime>=1000){ + do{ + secondes++; + maxTime-=1000; + }while(maxTime>=1000); + } + nanoSecondes = maxTime*1000000; + req.tv_sec = secondes; + req.tv_nsec = nanoSecondes; + nanosleep(&req, &rem); +} + +unsigned int aleatoire(unsigned int maxAlea){ + struct timeb t; + float a, b; + unsigned int nbmilli; + ftime(&t); + nbmilli = t.time * 1000 + t.millitm; + srand(nbmilli); + a = rand(); + b = (maxAlea * a) / RAND_MAX; + msleep(250); + return((unsigned int) b); +} + +void effacerEcran(){ + printf("%c[2J", 0x1B); + printf("\033[50A"); +} + +int comptageCaractere(char proposition[]){ + int nombre; + for(nombre = 0; proposition[nombre] != 0; nombre++){} + return nombre; +} + +void ecrireTextePendu(int nbCaractere, char carBon[TAILLEMAX]){ + int boucle; + + for(boucle = 0; boucle < nbCaractere; boucle++){ + if(carBon[boucle] != '\0'){ + printf("%c ", carBon[boucle]); + }else{ + printf("_ "); + } + } + printf("\n"); +} + +char verificationPendu(char aDeviner, char proposition, char carBon){ + if(aDeviner == proposition){ + return aDeviner; + }else{ + if(carBon != '\0'){} + else{ + return '\0'; + } + } +} + +void dessinerPendu(int lePendu){ + switch (lePendu){ + case 1: + printf(" \n \n \n \n \n \n \n \n \n \n"); + break; + case 2: + printf(" \n \n \n \n \n \n \n \n \n \n=================="); + break; + case 3: + printf(" \n || \n || \n || \n || \n || \n ||\n ||\n ||\n ||\n=================="); + break; + case 4: + printf(" \n || \n || \n || \n || \n || \n ||\n ||\n /||\n //||\n=================="); + break; + case 5: + printf(" \n || / \n || / \n ||/ \n || \n || \n ||\n ||\n /||\n //||\n=================="); + break; + case 6: + printf("\n ,==========Y===\n || / \n || / \n ||/ \n || \n || \n ||\n ||\n /||\n //||\n=================="); + break; + case 7: + printf("\n ,==========Y===\n || / |\n || / |\n ||/ \n || \n || \n ||\n ||\n /||\n //||\n=================="); + break; + case 8: + printf("\n ,==========Y===\n || / |\n || / |\n ||/ o\n || \n || \n ||\n ||\n /||\n //||\n=================="); + break; + case 9: + printf("\n ,==========Y===\n || / |\n || / |\n ||/ o\n || |\n || \n ||\n ||\n /||\n //||\n=================="); + break; + case 10: + printf("\n ,==========Y===\n || / |\n || / |\n ||/ o\n || /|\n || \n ||\n ||\n /||\n //||\n=================="); + break; + case 11: + printf("\n ,==========Y===\n || / |\n || / |\n ||/ o\n || /|\\\n || \n ||\n ||\n /||\n //||\n=================="); + break; + case 12: + printf("\n ,==========Y===\n || / |\n || / |\n ||/ o\n || /|\\\n || /\n ||\n ||\n /||\n //||\n=================="); + break; + case 13: + printf("\n ,==========Y===\n || / |\n || / |\n ||/ o\n || /|\\\n || /|\n ||\n ||\n /||\n //||\n=================="); + break; + } + printf("\n"); + + +} + +void exercice1(){ + int jour; + int mois; + int annee; + int tabJourMois[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30 ,31}; + + char nom[TAILLEMAX]; + char prenom[TAILLEMAX]; + + printf("Bienvenue dans l'exercice de synthèse !\n\n"); + + annee = acquisitionAnneeNaissance(); + mois = acquisitionMoisNaissance(); + jour = acquisitionJourNaissance(); + + printf("\n"); + + printf("Votre date de naissance est le %d/%d/%d.\n\n", jour, mois, annee); + + printf("Votre nom : "); + scanf("%s", nom); + printf("Votre prénom : "); + scanf("%s", prenom); + printf("\n"); + + printf("Bonjour %s %s.\n", prenom, nom); + + if(annee >= 1995){ + printf("Désolé, vous êtes trop jeune."); + }else{ + printf("Vous êtes autorisé à continuer."); + formatageDate(jour, mois, annee); + comptageMois(jour, mois, annee, tabJourMois); + verificationDateNaissance(jour, mois, tabJourMois); + affichageNomMois(jour, mois, annee); + } +} + +void exercice2(){ + char proposition[5]; + char couleur[5] = {'r', 'r', 'v', 'b', 'b'}; + int deroulementCouleur; + int nbPosBon; + int tentative = 0; + + printf("Bienvenue dans le jeu MinorMind !\n\n"); + printf("Arriverez vous à deviner la couleur ?\n"); + + do{ + tentative++; + printf("Votre proposition (ex: rbvbr) : "); + scanf(" %c%c%c%c%c", &proposition[0], &proposition[1], &proposition[2], &proposition[3], &proposition[4]); + + nbPosBon = 0; + if((proposition[0] == 'r' || proposition[0] == 'v' || proposition[0] == 'b') + && (proposition[1] == 'r' || proposition[1] == 'v' || proposition[1] == 'b') + && (proposition[2] == 'r' || proposition[2] == 'v' || proposition[2] == 'b') + && (proposition[3] == 'r' || proposition[3] == 'v' || proposition[3] == 'b') + && (proposition[4] == 'r' || proposition[4] == 'v' || proposition[4] == 'b')){ + for(deroulementCouleur = 0; deroulementCouleur < 5; deroulementCouleur++){ + if(proposition[deroulementCouleur] == couleur[deroulementCouleur]){ + nbPosBon++; + } + } + printf("%d de vos couleurs sont à la bonne place.\n", nbPosBon); + }else{ + printf("Saisie incorrecte.\n"); + } + }while(nbPosBon < 5); + printf("Félicitations !\n"); + printf("La séquence %c%c%c%c%c était la bonne !\n", couleur[0], couleur[1], couleur[2], couleur[3], couleur[4]); + printf("Vous avez réussi à trouver la bonne séquence en %d tentative(s).\n", tentative); +} + +void exercice3(){ + char phrasesENA[4][8][255] = {{"Mesdames, mesieurs, ", "Je reste fondamentalement persuadé que ", "Dès lors, sachez que je me battrai pour faire admettre que", "Par ailleurs, c'est en toute connaissance de cause que je peux affirmer aujourd'hui que ", "Je tiens à vous dire ici ma détermination sans faille pour clamer haut et fort que ", "J'ai depuis longtemps (ai-je besoin de vous le rappeler?), défendu l'idée que ", "Et c'est en toute conscience que je déclare avec conviction que ", "Et ce n'est certainement pas vous, mes chers compatriotes, qui me contredirez si je vous dis que "}, + {"la conjoncture actuelle ", "la situation d'exclusion que certains d'entre vous connaissent ", "l'acuité des problèmes de la vie quotidienne ", "la volonté farouche de sortir notre pays de la crise ", "l'effort prioritaire en faveur de statut précaire des exclus ", "le particularisme dû à notre histoire unique ", "l'aspiration plus que légitime de chacun au progrès social ", "la nécessité de répondre à votre inquiétude journalière, que vous soyez jeunes ou âgés, ", "Je reste fondamentalement persuadé que "}, + {"doit s'intégrer à la finalisation globale ", "oblige à la prise en compte encore plus effective ", "interpelle le citoyen que je suis et nous oblige tous à aller de l'avant dans la voie ", "a pour conséquence obligatoire l'urgente nécessité ", "conforte mon désir incontestable d'aller dans le sens ", "doit nous amener au choix réellement impératif ", "doit prendre en compte les préoccupations de la population de la base dans l'élaboration ", "entraine une mission somme toute des plus exaltantes pour moi : l'élaboration "}, + {"d'un projet porteur de véritable espoirs, notamment pour les plus démunis.", "d'un programme plus humain, plus fraternel et plus juste.", "de solutions rapides correspondant aux grands axes sociaux prioritaies.", "d'un plan correspondant véritablement aux exigences légitimes de chacun.", "d'une valorisation sans concession de nors caractères spécifiques.", "d'une restructuration dans laquelle chacun pourra enfin retrouver sa dignité.", "d'un avenir s'orientant vers plus de progrès et plus de justice.", "d'un processus allant vers plus d'égalité."}}; + + int nbPhrase; + int genererPhrase; + + printf("Combien de phrases voulez-vous générer ?"); + scanf("%d", &nbPhrase); + for(genererPhrase = 0; genererPhrase < nbPhrase; genererPhrase++){ + printf("%d :\n", genererPhrase+1); + printf("%s%s%s%s", phrasesENA[0][aleatoire(7)], phrasesENA[1][aleatoire(7)] + , phrasesENA[2][aleatoire(7)], phrasesENA[3][aleatoire(7)]); + printf("\n"); + } +} + +void exercice4(){ + char proposition; + char carBon[TAILLEMAX]; + char comparaisonCarBon[TAILLEMAX]; + char aDeviner[TAILLEMAX]; + int nbCaractere; + int curseur; + int lePendu = 1; + int comparaison; + + printf("Bienvenue dans le jeu du pendu !\n\n"); + printf("Saisir le mot à deviner :"); + scanf("%s", aDeviner); + + effacerEcran(); + + do{ + printf("\nProposer une lettre :"); + scanf(" %c", &proposition); + + effacerEcran(); + + for(curseur = 0; curseur < TAILLEMAX; curseur++){ + comparaisonCarBon[curseur] = carBon[curseur]; + } + + nbCaractere = comptageCaractere(aDeviner); + for(curseur = 0; curseur < TAILLEMAX; curseur++){ + carBon[curseur] = verificationPendu(aDeviner[curseur], proposition, carBon[curseur]); + } + + if(strcmp(comparaisonCarBon, carBon) == 0){ + lePendu++; + printf("Votre lettre n'est pas présente dans le mot à deviner.\n"); + }else{ + printf("Votre lettre est bien dans le mot à deviner.\n"); + } + + for(curseur = 0; curseur < 50; curseur++){ + comparaisonCarBon[curseur] = carBon[curseur]; + } + + ecrireTextePendu(nbCaractere, carBon); + dessinerPendu(lePendu); + }while((strcmp(carBon, aDeviner) != 0) && (lePendu < 13)); + if(lePendu == 13){ + effacerEcran(); + printf("GAME OVER\n\n"); + printf("Vous avez tué notre bon vieux M.Bidochon...\n"); + printf("Le mot était %s.\n", aDeviner); + }else{ + effacerEcran(); + printf("Vous avez gagné, félicitations ! \nVous avez sauvé M.Bidochon de la pendaison.\n"); + printf("\nLe mot à deviner était bien %s !\n", aDeviner); + } +} + +int main() +{ + int numExercice; + + do{ + printf("Bienvenue dans le programme d'occupation de vacances.\n"); + printf("Quel exercice souhaitez-vous essayer ?\n"); + printf("1 - Synthèse Septembre Octobre\n"); + printf("2 - MinorMind\n"); + printf("3 - Générateur de langue de bois\n"); + printf("4 - Le pendu\n"); + printf("Votre choix : "); + scanf("%d", &numExercice); + + switch (numExercice){ + case 1: + effacerEcran(); + exercice1(); + break; + case 2: + effacerEcran(); + exercice2(); + break; + case 3: + effacerEcran(); + exercice3(); + break; + case 4: + effacerEcran(); + exercice4(); + break; + default: + printf("La valeur est incorrecte, réessayez."); + } + }while(numExercice < 1 || numExercice > 4); +} diff --git a/BTS/C/Premiere annee/golfPourEtudiants/.~lock.tpctrlGolf_2015.odt# b/BTS/C/Premiere annee/golfPourEtudiants/.~lock.tpctrlGolf_2015.odt# new file mode 100644 index 0000000..4c33130 --- /dev/null +++ b/BTS/C/Premiere annee/golfPourEtudiants/.~lock.tpctrlGolf_2015.odt# @@ -0,0 +1 @@ +,dbernard,b108tu4p4.depinfo.touchard.edu,14.01.2016 08:26,file:///home/USERS/PROFS/dbernard/.config/libreoffice/4; \ No newline at end of file diff --git a/BTS/C/Premiere annee/golfPourEtudiants/golf.c b/BTS/C/Premiere annee/golfPourEtudiants/golf.c new file mode 100644 index 0000000..250600f --- /dev/null +++ b/BTS/C/Premiere annee/golfPourEtudiants/golf.c @@ -0,0 +1,839 @@ +/*************************************************************************** +golf.c + ***************************************************************************/ +#include "golf.h" + + +/* + * paramètre d'entrées : le nombre actuel d'element(s) du tableau + * + * en entrées : + * + * paramètre de sortie + * + * paramètre d'E/S un tableau de pointeur(s) sur parcours + * + * en sortie : + + * valeur retournée : le nouveau nombre de parcours present dans le tableau + * + * DESCRIPTION : creation dynamique d'un parcours, initialisation + * et ajout de ce dernier dans le tableau des parcours + * + */ +int creerParcours( typeParcours *tab[], int nbParcours ) +{ + int i; + // creation du parcours a l'indice nbParcours + tab[nbParcours] = ( typeParcours* ) malloc( sizeof( typeParcours ) ); + printf( "\nnom du parcours " ); + scanf( "%s", tab[nbParcours]->nom ); + printf( "nombre de trous " ); + scanf( "%d", &tab[nbParcours]->nbTrou ); + + // initialisation des trous + for ( i = 0;i < tab[nbParcours]->nbTrou;i++ ) + { + printf( "numero du trou : %d\n", i + 1 ); + tab[nbParcours]->listeTrous[i].numero = i + 1; + printf( "distance (en metre) : " ); + scanf( "%f", &tab[nbParcours]->listeTrous[i].distance ); + printf( "valeur du par : " ); + scanf( "%d", &tab[nbParcours]->listeTrous[i].par ); + printf( "nombre maximum de coups pour ce trou : " ); + scanf( "%d", &tab[nbParcours]->listeTrous[i].nbMaxCoups ); + } + + return nbParcours + 1; +} + +/* + * paramètre d'entrées : un tableau de pointeur(s) sur parcours + le numero d'index du parcours a afficher + * + * en entrées : + * + * paramètre de sortie + * + * paramètre d'E/S + * + * en sortie : affichage de info à l'ecran + + * valeur retournée : + * + * DESCRIPTION : afficher les informations d'un parcours particulier + * + */ +void afficherUnParcours( typeParcours *tab[], int nro ) +{ + int i; + printf( "\nnom du parcours %s\n", tab[nro]->nom ); + printf( "nombre de trous %d\n", tab[nro]->nbTrou ); + + // afficher le detail de chaque trou du parcours + for ( i = 0;i < tab[nro]->nbTrou;i++ ) + { + afficherInfoTrou( tab[nro]->listeTrous[i] ); + } +} + + +/* + * paramètre d'entrées : un tableau de pointeur(s) sur parcours + le nombre actuel d'element(s) du tableau + * + * en entrées : + * + * paramètre de sortie + * + * paramètre d'E/S + * + * en sortie : fichier contenant l'ensemble des parcours + + * valeur retournée : + * + * DESCRIPTION : sauvegarder les donnees des parcours dans un fichier + * + */ +void sauvegarderParcours( typeParcours *tab[], int nbParcours ) +{ + FILE *fd; + int i; + int nbEnregistrement; + int retourFclose; + // ouverture du fichier des parcours en ecriture + fd = fopen( FICHIER_PARCOURS, "w+" ); + if ( fd == NULL ) + { + printf( "%s\n", strerror( errno ) ); + exit( errno ); + } + + //ecriture de chacun des parcours + for ( i = 0; i < nbParcours; i++ ) + { + nbEnregistrement=fwrite( tab[i], sizeof( typeParcours ), 1, fd ); + if (nbEnregistrement!=1) + { + printf( " pb sauvegarde parcours%s\n", strerror( errno ) ); + exit( errno ); + + } + } + + retourFclose=fclose( fd ); + if(retourFclose==EOF) + { + printf( " pb fermeture sauvegarde parcours%s\n", strerror( errno ) ); + exit( errno ); + } +} + +/* + * paramètre d'entrées : + + * + * en entrées : fichier contenant l'ensemble des parcours + * + * paramètre de sortie : un tableau de pointeur(s) sur parcours + * + * paramètre d'E/S + * + * en sortie : + + * valeur retournée : le nombre actuel d'element(s) du tableau des parcours + * + * DESCRIPTION : initialiser le tableau des parcours + * à partir d'un fichier + * + */ +int chargerParcours( typeParcours *tab[] ) +{ + FILE *fd; + int nbEnregistrement; + int i = 0; + int retourFclose; + // ouverture du fichier des parcours en lecture + fd = fopen( FICHIER_PARCOURS, "r" ); + + if ( fd == NULL ) + { + printf( "%s\n", strerror( errno ) ); + exit( errno ); + } + + // lecture et stockage de tous les parcours + while ( !feof( fd ) ) + { + // reservation memoire pour stokcer un parcours + tab[i] = ( typeParcours* ) malloc( sizeof( typeParcours ) ); + //lecture d'un parcours + nbEnregistrement=fread( tab[i], sizeof( typeParcours ), 1, fd ); + if (nbEnregistrement!=1) // pb de lecture + { + if (!feof(fd)) + { + printf( " pb lecture charger parcours%s\n", strerror( errno ) ); + exit( errno ); + } + else + { + // c'est la fin de fichier + // on a donc réserve une case en trop pour les parcours + // il faut la supprimer + free( tab[i] ); + + } + + } + else + { + // augmentation du nombre de parcours lu + i++; + } + + + } + + retourFclose=fclose( fd ); + if(retourFclose==EOF) + { + printf( " pb fermeture charger parcours%s\n", strerror( errno ) ); + exit( errno ); + } + + // je retourne le nombre de parcours maintenant present dans mon tableau + return i; +} + + +/* + * retourne une valeur entiere E[0..maxAlea[ + */ +float aleatoire( float maxAlea ) +{ + /* struct timeb { + time_t time; + unsigned short millitm; + short timezone; + short dstflag; + };*/ + + struct timeb t; + //long t; + float a, b ; + unsigned int nbmilli; + ftime( &t ); + nbmilli = t.time * 1000 + t.millitm; + srand( nbmilli ); + a = rand(); + b = ( maxAlea * a ) / RAND_MAX; + return ( b ); + + +} +/* + * retourne un entier entre min et max +*/ +float lancement( float min, float max ) +{ + float lancee; + lancee = min + aleatoire( max - min ); + return ( lancee ); +} + + +/* + * paramètre d'entrées : un trou + * la difficulte sur le green + * + * + * en entrées : le choix du club utilise + * + * paramètre de sortie : + * + * paramètre d'E/S + * + * en sortie : affichage de la distance restante + * et du nombre de points + + * valeur retournée : le nombre de coups effectue pour arriver au trou + * + * DESCRIPTION : jouer un trou -> + * demander autant de fois que necessaire + * le type de club a utilise + * jusqu'à arriver au trou. + * ->la difficulte est de determiner à partir de + * combien de metres du trou + * une balle est consideree dans le trou. + * + */ +int jouerTrou( typeTrou t, float difficulte ) +{ + int fin = 1; // la balle n'est pas dans le trou + float dist = t.distance; + int nbCoups = 1; + char choix; + + do + { + printf( "=============== coups nro %d\n", nbCoups ); + printf( "choix du club : \n[D]river\n[B]ois\n[F]er\n[P]utter\n" ); + scanf( " %c", &choix ); + choix = toupper( choix ); + // en fonction du choix de club, je reduis la distance avec le trou + + switch ( choix ) + { + + case 'D': + dist -= lancement( DRIVER_MIN, DRIVER_MAX ); + break; + + case 'B': + dist -= lancement( BOIS_MIN, BOIS_MAX ); + break; + + case 'F': + dist -= lancement( FER_MIN, FER_MAX ); + break; + + case 'P': + dist -= lancement( PUTTER_MIN, PUTTER_MAX ); + break; + } + + if ( dist <= 0.0 ) + {// si je depasse le trou je remets une distance positive + dist = -dist; + + if ( dist > difficulte ) + printf( "%svous avez depasse le trou%s\n", RED, GREY ); + } + + if ( dist <= difficulte && dist >= 0.0 ) + {// la balle est dans le trou + fin = 0; + } + if ( nbCoups == t.nbMaxCoups ) + {// j'ai atteint le nombre maxi de coups pour le trou + if ( fin != 0 ) + {// et en plus la balle n'est toujours pas dans le trou + printf( "%sNombre de coups maxi atteint!! abandon de ce trou%s\n", RED, GREY ); + } + + fin = 0; + } + + if ( fin != 0 ) + {// je dois rejouer, j'affiche la distance restante + nbCoups++; + printf( "=================================================\n" ); + printf( "il vous reste %.1f metres avant le trou\n", dist ); + printf( "=================================================\n" ); + } + } + while ( fin != 0 ); + + printf( "\n\n\n" ); + + // suivant le nombre de coups joue par rapport au "par" du trou + // j'affiche la designation correspondante + switch ( nbCoups - t.par ) + { + + case CONDOR: + printf( "%s CONDOR !!!! %d\n%s", YELLOW, CONDOR, GREY ); + break; + + case ALBATROS: + printf( "%s ALBATROS!!! %d\n%s", YELLOW, ALBATROS, GREY ); + break; + + case EAGLE: + printf( "%sEAGLE!! %d%s\n", YELLOW, EAGLE, GREY ); + break; + + case BIRDIE: + printf( "%sBIRDIE! %d%s\n", YELLOW, BIRDIE, GREY ); + break; + + case PAR: + printf( "PAR %d\n", PAR ); + break; + + case BOGEY: + printf( "%sBOGEY +%d%s\n", RED, BOGEY, GREY ); + break; + + case DOUBLE_BOGEY: + printf( "%sDOUBLE_BOGEY +%d%s\n", RED, DOUBLE_BOGEY, GREY ); + break; + + case TRIPLE_BOGEY: + printf( "%sTRIPLE_BOGEY +%d%s\n", RED, TRIPLE_BOGEY, GREY ); + break; + + default: + printf( "%s+%d%s\n", RED, nbCoups - t.par, GREY ); + } + + printf( "\n\n\n" ); + + // retourne le nombre de coups joue pour ce trou + return ( nbCoups ); +} + + + + +/* + * paramètre d'entrées : un pointeur sur un score + * + * en entrées : + * + * paramètre de sortie : + * + * paramètre d'E/S + * + * en sortie : affichage du score d'un joueur pour un parcours + * valeur retournée : + * + * DESCRIPTION : affichage du score d'un joueur pour un parcours + * + */ +void afficherScore( typeScore *s ) +{ + int i, total = 0; + + printf( "score de%s %s:%s\n", CYAN, s->nomJoueur, GREY ); + printf( "parcours : %s difficulte : ", s->parcoursJoue.nom ); + + // suivant la valeur de la difficulte, afficher la difficulte en toute lettre + switch ( s->difficulte ) + { + + case 0: + printf( "infernale\n" ); + + case 1: + printf( "tres difficile\n" ); + + case 2: + printf( "difficile\n" ); + + case 3: + printf( "normale\n" ); + + case 4: + printf( "facile\n" ); + + case 5: + printf( "tres facile\n" ); + } + + // affichage de la grille avec le numero des trous, les valeurs des "par" et le score du joueur + printf( "--------------" ); + + for ( i = 0;i < s->parcoursJoue.nbTrou + 1;i++ ) + { + printf( "----" ); + } + + printf( "\n" ); + + //affichage des numeros de trou + printf( "nro Trou " ); + + for ( i = 0;i < s->parcoursJoue.nbTrou;i++ ) + { + if ( i < 10 ) + { + printf( "| %.1d ", i + 1 ); + } + else + { + printf( "| %.2d", i + 1 ); + } + } + + printf( "|TOT" ); + + printf( "\n" ); + printf( "--------------" ); + + for ( i = 0;i < s->parcoursJoue.nbTrou + 1;i++ ) + { + printf( "----" ); + } + + printf( "\n" ); + + //affichage des valeurs de "par" pour chaque trou + printf( "valeur du par " ); + + for ( i = 0;i < s->parcoursJoue.nbTrou;i++ ) + { + printf( "| %.1d ", s->parcoursJoue.listeTrous[i].par ); + total += s->parcoursJoue.listeTrous[i].par; + } + + printf( "| %.2d", total ); + + printf( "\n" ); + total = 0; + printf( "--------------" ); + + for ( i = 0;i < s->parcoursJoue.nbTrou + 1;i++ ) + { + printf( "----" ); + } + + printf( "\n" ); + + //affichage du score du joueur + printf( "score " ); + + for ( i = 0;i < s->parcoursJoue.nbTrou;i++ ) + { + printf( "| " ); + + if ( s->points[i] > ( s->parcoursJoue.listeTrous[i].par ) ) + printf( "%s", RED ); + + if ( s->points[i] < ( s->parcoursJoue.listeTrous[i].par ) ) + printf( "%s", YELLOW ); + + printf( "%.1d %s", s->points[i], GREY ); + + total += s->points[i]; + } + + printf( "| %.2d", total ); + + printf( "\n" ); + printf( "--------------" ); + + for ( i = 0;i < s->parcoursJoue.nbTrou + 1;i++ ) + { + printf( "----" ); + } + + printf( "\n" ); +} + + +/* + * paramètre d'entrées : le nombre de scores present dans le tableau des scores + * + * en entrées : + * + * paramètre de sortie : + * + * paramètre d'E/S tableau de pointeurs sur des scores + * + * en sortie : le tableau des scores trie + * selon la somme des coups par ordre croissant + * valeur retournée : + * + * DESCRIPTION : trier les scores du meilleur au plus mauvais + * + */ +void classement( typeScore *tab[], int nbScore ) +{ + int i, j, k; + typeScore *tmp; + int sommei = 0, sommej = 0; + + for ( i = 0;i < nbScore;i++ ) + { + sommei = 0; + // calcul de la somme des points au rang i + for ( k = 0;k < tab[i]->parcoursJoue.nbTrou;k++ ) + sommei += tab[i]->points[k]; + + for ( j = i;j < nbScore;j++ ) + { + sommej = 0; + // calcul de la somme des points au rang j + for ( k = 0;k < tab[j]->parcoursJoue.nbTrou;k++ ) + sommej += tab[j]->points[k]; + + // si le score au rang j est plus petit qu'au rang i swapper les pointeurs + if ( sommej < sommei ) + { + tmp = tab[i]; + tab[i] = tab[j]; + tab[j] = tmp; + } + + } + } + +} + + +/**************************************************************************************************** +**************************************************************************************************** +**************************************************************************************************** + fonctions a coder/completer +**************************************************************************************************** +**************************************************************************************************** +****************************************************************************************************/ + +void afficherMenu(int nbParcours, int nbScores) +{ + if(nbParcours > 0) + { + printf("[J] Jouer un parcours\n"); + printf("[D] Jouer un parcours avec 2 joueurs\n"); + printf("[V] Afficher un parcours\n"); + } + + if(nbScores > 0) + { + printf("[Z] Classement\n"); + } + + printf("[C] Creer un parcours\n"); + printf("[Q] Quitter\n"); + + printf("Votre choix :"); +} + + +/* + * paramètre d'entrées : un trou + * + * en entrées : + * + * + * paramètre de sortie : + * + * paramètre d'E/S + * + * en sortie : Affichage des champs du trou + + * valeur retournée : + * + * DESCRIPTION : Affichage des caracteristiques d'un trou + * + * + */ +void afficherInfoTrou( typeTrou unTrou) +{ + printf("[Trou numero %d |", unTrou.numero); + printf(" Distance %.2f metres |", unTrou.distance); + printf(" Par %d |", unTrou.par); + printf(" %d coups maximum]\n", unTrou.nbMaxCoups); +} + + +/* + * paramètre d'entrées : tableau de pointeur sur des parcours + nombre de parcours actuellement dans le tableau + * + * en entrées : + * + * + * paramètre de sortie : + * + * paramètre d'E/S + * + * en sortie : affichage de l'index(numero d'indice) de chaque parcours suivi de son nom + + * valeur retournée : + * + * DESCRIPTION : Affichage des différents parcours disponibles + * + * + */ +void afficherLesParcours( typeParcours *tab[], int nbParcours ) +{ + int i; + + for(i = 0; i < + nbParcours; i++) + { + printf("%d - %s\n", i, tab[i]->nom); + } +} + + + +/* + * paramètre d'entrées : un pointeur sur le parcours a jouer + * + * en entrées : nom du joueur + * difficulte de la partie + * + * paramètre de sortie : + * + * paramètre d'E/S + * + * en sortie : affichage des differents coups joues + affichage du score + mise à jour du fichier des scores + + * valeur retournée : un pointeur sur le score du joueur + * + * DESCRIPTION : creation d'un joueur avec son score, + * joue chaque trou du parcours. + * + */ +typeScore *jouerParcours( typeParcours *p ) +{ + typeScore *sc; + int i; + float niveau; + // creation d'un nouveau score + sc = ( typeScore* ) malloc( sizeof( typeScore ) ); + + printf( "votre nom :" ); + scanf( "%s", sc->nomJoueur ); + printf( "difficulte [0-infernale .. 5-tres facile]" ); + scanf( "%d", &sc->difficulte ); + niveau = 1.0 + 3.0 * ( float ) sc->difficulte; + // recopie des donnees du parcours fait par le joueur + memcpy( &sc->parcoursJoue, p, sizeof( typeParcours ) ); + + printf( "parcour %s\n", p->nom ); +/*****************************************************************************************/ + // pour chaque trou du parcours + // afficher les informations concernant le trou + // jouer le trou et sauvegarder le nombre de coups joue dans le tableau + // des points du joueur + for ( i = 0;i < p->nbTrou;i++ ) + { + afficherInfoTrou( p->listeTrous[i] ); + sc->points[i] = jouerTrou( p->listeTrous[i], niveau ); + } + + // afficher le score du joueur pour ce parcours + afficherScore( sc ); + + // sauvegarder ce score + + sauvegarderScore(sc); + +/*****************************************************************************************/ + return sc; +} + +void sauvegarderScore( typeScore *sc ) +{ + FILE *fd; + int erreurEcriture; + int erreurFClose; + + fd = fopen( FICHIER_SCORE, "w+"); + + erreurEcriture = fwrite(sc, sizeof(typeScore), 1, fd); + if(erreurEcriture != 1) + { + printf("Probleme sauvegarde scores%s\n", strerror(errno)); + exit(errno); + } + + erreurFClose = fclose(fd); + if(erreurFClose == EOF) + { + printf("Probleme fermeture sauvegarde scores%s\n", strerror(errno)); + exit(errno); + } +} + +int chargerLesScores( typeScore *tab[] ) +{ + FILE *fd; + int i = 0; + int erreurLecture; + int erreurFClose; + + fd = fopen(FICHIER_SCORE, "r"); + if(fd == NULL) + { + printf("%s\n", strerror(errno)); + exit(errno); + } + + while(!feof(fd)) + { + tab[i] = (typeScore*) malloc(sizeof(typeScore)); + + erreurLecture = fread(tab[i], sizeof(typeScore), 1, fd); + if(erreurLecture != 1) + { + if(!feof(fd)) + { + printf("Probleme lecture chargement scores%s\n", strerror(errno)); + exit(errno); + } + else + { + free(tab[i]); + } + } + else + { + i++; + } + } + erreurFClose = fclose(fd); + if(erreurFClose == EOF) + { + printf("Probleme fermeture chargement scores%s\n", strerror(errno)); + exit(errno); + } + + return i; + +} + +void jouerParcoursADeux( typeParcours *p ) +{ + typeScore *scP1; + typeScore *scP2; + int i; + float niveauP1; + float niveauP2; + // creation d'un nouveau score + scP1 = ( typeScore* ) malloc( sizeof( typeScore ) ); + scP2 = ( typeScore* ) malloc( sizeof( typeScore ) ); + + printf( "Nom player 1 :" ); + scanf( "%s", scP1->nomJoueur ); + printf( "difficulte player 1 [0-infernale .. 5-tres facile]" ); + scanf( "%d", &scP1->difficulte ); + + printf( "Nom player 2 :" ); + scanf( "%s", scP2->nomJoueur ); + printf( "difficulte player 2 [0-infernale .. 5-tres facile]" ); + scanf( "%d", &scP2->difficulte ); + + niveauP1 = 1.0 + 3.0 * ( float ) scP1->difficulte; + niveauP2 = 1.0 + 3.0 * ( float ) scP2->difficulte; + + // recopie des donnees du parcours fait par le joueur + memcpy( &scP1->parcoursJoue, p, sizeof( typeParcours ) ); + memcpy( &scP2->parcoursJoue, p, sizeof( typeParcours ) ); + + printf( "parcour %s\n", p->nom ); + + // pour chaque trou du parcours + // afficher les informations concernant le trou + // jouer le trou et sauvegarder le nombre de coups joue dans le tableau + // des points du joueur + for ( i = 0;i < p->nbTrou;i++ ) + { + afficherInfoTrou( p->listeTrous[i] ); + printf("%s", scP1->nomJoueur); + scP1->points[i] = jouerTrou( p->listeTrous[i], niveauP1 ); + printf("%s", scP2->nomJoueur); + scP2->points[i] = jouerTrou( p->listeTrous[i], niveauP2 ); + } + + afficherScore( scP1 ); + afficherScore( scP2 ); +} + diff --git a/BTS/C/Premiere annee/golfPourEtudiants/golf.h b/BTS/C/Premiere annee/golfPourEtudiants/golf.h new file mode 100644 index 0000000..83505e7 --- /dev/null +++ b/BTS/C/Premiere annee/golfPourEtudiants/golf.h @@ -0,0 +1,101 @@ +/*************************************************************************** +golf.h + ***************************************************************************/ +#ifndef GOLF_H +#define GOLF_H + +#include +#include +#include +#include +#include +#include +#include + +#define NBMAXPARCOURS 20 +#define NBMAXSCORES 50 +#define NBMAXTROU 18 +#define NBMAXCAR 50 + +#define FICHIER_SCORE "/home/USERS/ELEVES/SNIR2015/therbron/workspace/golfPourEtudiants/scores.bin" +#define FICHIER_PARCOURS "/home/USERS/ELEVES/SNIR2015/therbron/workspace/golfPourEtudiants/parcoursGolf.bin" + +// distance min et max en fonction des clubs +#define DRIVER_MIN 190.0 +#define DRIVER_MAX 210.0 +#define BOIS_MIN 150.0 +#define BOIS_MAX 190.0 +#define FER_MIN 30.0 +#define FER_MAX 150.0 +#define PUTTER_MIN 1.0 +#define PUTTER_MAX 30.0 + +#define BLACK "\033[1;30m" +#define RED "\033[1;31m" +#define GREEN "\033[1;32m" +#define YELLOW "\033[1;33m" +#define BLUE "\033[1;34m" +#define PURPLE "\033[1;35m" +#define CYAN "\033[1;36m" +#define GREY "\033[1;37m" + + +typedef enum {CONDOR = -4, ALBATROS, EAGLE, BIRDIE, PAR, BOGEY, DOUBLE_BOGEY, TRIPLE_BOGEY}enumPoint; + +/**************************************** +definition du type : typeTrou +******************************************/ +typedef struct +{ + int numero; + float distance; + int par; + int nbMaxCoups; +}typeTrou; + +/**************************************** +definition du type : typeParcours +******************************************/ + +typedef struct +{ + char nom[NBMAXCAR]; + int nbTrou; + typeTrou listeTrous[NBMAXTROU]; +}typeParcours; + +/**************************************** +definition du type : typeScore +******************************************/ +typedef struct +{ + char nomJoueur[NBMAXCAR]; + int difficulte; + typeParcours parcoursJoue; // le parcours auquel le score se rapporte + int points[NBMAXTROU]; // tableau des scores pouvant aller jusqu'a 18 trous +}typeScore; + +int creerParcours( typeParcours *tab[], int nbParcours ); +void afficherUnParcours( typeParcours *tab[], int nro ); +void sauvegarderParcours( typeParcours *tab[], int nbParcours ); +int chargerParcours( typeParcours *tab[] ); +typeScore *jouerParcours( typeParcours *p ); +int jouerTrou( typeTrou, float ); +float aleatoire( float maxAlea ); +float lancement( float min, float max ); +void afficherScore( typeScore * ); +void classement( typeScore *tab[], int nbScore ); + +/************************************************************ + fonctions a coder/completer +************************************************************/ +void afficherInfoTrou( typeTrou unTrou); +void afficherLesParcours( typeParcours *tab[], int nbParcours ); +typeScore *jouerParcours( typeParcours *p ); +void sauvegarderScore( typeScore *sc ); +int chargerLesScores( typeScore *tab[] ); +void jouerParcoursADeux( typeParcours *p ); +void afficherMenu(int nbParcours, int nbScores); + + +#endif diff --git a/BTS/C/Premiere annee/golfPourEtudiants/main.c b/BTS/C/Premiere annee/golfPourEtudiants/main.c new file mode 100644 index 0000000..cb8e077 --- /dev/null +++ b/BTS/C/Premiere annee/golfPourEtudiants/main.c @@ -0,0 +1,120 @@ +/********************************************************* + * + * NOM : main.c + * TYPE : APPLICATION + * SUJET : simulation de jeu de golf + * + * AUTEUR : + * VERSION : + * CREATION : 08/01/2014 + * DER. MODIF. : 05/01/2016 + * + * ACCES SRC : + * ACCES OBJ : + * ACCES EXEC : + * FABRICATION : codeblocks + * + * LIMITES : 20 parcours maximum, 50 parties stockables au maxi + * CONTRAINTES : sous linux pour avoir de la couleur + * + ******************************************************** +*/ +#include +#include +#include +#include "golf.h" + +int main( int argc, char *argv[] ) +{ + + typeScore *scores[NBMAXSCORES]; + + /********************************************** + declaration du tableau des parcours + **********************************************/ + + typeParcours *tab[NBMAXPARCOURS]; + + int nbParcours = 0; + int nbScores = 0; + char choix; + int nro, i; + nbParcours = chargerParcours( tab ); + nbScores = chargerLesScores( scores ); + + do + { + /********************* + appel a la fonction afficherMenu + *********************/ + + afficherMenu(nbParcours, nbScores); + + scanf( " %c", &choix ); + choix = toupper( choix ); + + switch ( choix ) + { + + case 'C': + nbParcours = creerParcours( tab, nbParcours ); + sauvegarderParcours( tab, nbParcours ); + break; + + case 'V': + afficherLesParcours( tab, nbParcours ); + printf( "Numero du parcours a afficher :" ); + scanf( " %d", &nro ); + afficherUnParcours( tab, nro ); + break; + + case 'J': + afficherLesParcours( tab, nbParcours ); + printf( "Numero du parcours sur lequel vous voulez jouer :" ); + scanf( " %d", &nro ); + scores[nbScores++] = jouerParcours( tab[nro] ); + break; + + case 'D': + afficherLesParcours( tab, nbParcours ); + printf( "Numero du parcours sur lequel vous voulez jouer :" ); + scanf( " %d", &nro ); + jouerParcoursADeux( tab[nro] ); + break; + + case 'Z': + classement( scores, nbScores ); + printf( "classement [G]lobale ou selon un circuit [P]articulier?\n" ); + scanf( " %c", &choix ); + choix = toupper( choix ); + + if ( choix == 'P' ) + { + afficherLesParcours( tab, nbParcours ); + printf( "Numero du parcours sur lequel vous voulez le classement :" ); + scanf( " %d", &nro ); + } + + for ( i = 0;i < nbScores;i++ ) + { + if ( choix != 'G' ) + { + if ( strcmp( scores[i]->parcoursJoue.nom, tab[nro]->nom ) == 0 ) + { + afficherScore( scores[i] ); + } + } + else + { + afficherScore( scores[i] ); + } + } + + break; + + } + } + while ( choix != 'Q' ); + + return EXIT_SUCCESS; +} diff --git a/BTS/C/Premiere annee/jeu_revolutionnaire.c b/BTS/C/Premiere annee/jeu_revolutionnaire.c new file mode 100644 index 0000000..1d66294 --- /dev/null +++ b/BTS/C/Premiere annee/jeu_revolutionnaire.c @@ -0,0 +1,27 @@ +#include +#include +#include + +int main() +{ + srand(time(NULL)); + int aTrouver = rand() % 100; + int trouve = 0; + int userEnter, essai = 0; + while(trouve == 0){ + printf("Entrer une valeur :"); + scanf("%d", &userEnter); + if(userEnter < aTrouver){ + printf("La valeur à trouver est plus grande.\n"); + essai++; + }else{ + if(userEnter > aTrouver){ + printf("La valeur à trouver est plus petite.\n"); + essai++; + }else{ + printf("Vous avez trouvé en %d essai(s).", essai); + trouve = 1; + } + } + } +} diff --git a/BTS/C/Premiere annee/meteo.c b/BTS/C/Premiere annee/meteo.c new file mode 100644 index 0000000..bf768be --- /dev/null +++ b/BTS/C/Premiere annee/meteo.c @@ -0,0 +1,50 @@ +#include +#include +#define NBETAT 3 + +int main() +{ + unsigned char meteo = 0x12; + unsigned char tendance; + unsigned char etat; + char *tendancePression[NBETAT]={"stable", "en hausse", "en baisse"}; + char *etatCiel[NBETAT]={"pluvieux", "nuageux", "ensoleille"}; + + tendance = meteo & 0x0F; + + etat = meteo & 0xF0; + etat = etat >> 4; + + printf("La pression est %s\n", tendancePression[tendance]); + printf("Le ciel est %s\n", etatCiel[etat]); + + + + /*switch (tendance) + { + case 0: + printf("Pression stable \n"); + break; + case 1: + printf("Pression en hausse \n"); + break; + case 2: + printf("Pression en baisse \n"); + break; + } + + switch (etat) + { + case 0: + printf("Ciel pluvieux\n"); + break; + case 16: + printf("Ciel nuageux\n"); + break; + case 32: + printf("Ciel ensoleille\n"); + break; + }*/ + + return 0; +} diff --git a/BTS/C/Premiere annee/modificationImage/biblio.c b/BTS/C/Premiere annee/modificationImage/biblio.c new file mode 100644 index 0000000..7acb3c8 --- /dev/null +++ b/BTS/C/Premiere annee/modificationImage/biblio.c @@ -0,0 +1,22 @@ +#include "biblio.h" +#define TAILLEMAX 255 + +void afficheEnTeteFichierBmp(FILE* pImage) +{ + enTeteFichierBMP enTete; + fread(&enTete, sizeof(enTeteFichierBMP), 1, pImage); + + printf("Signature : %c%c\nTaille : %d\nRéserve : %d\nAdresse relative : %d\n",enTete.signature[0],enTete.signature[1],enTete.tailleFichier,enTete.reserve,enTete.adresseRelative); + + +} + +void afficheEnTeteImageBmp(FILE* pImage) +{ + enTeteImageBMP enTete; + fread(&enTete, sizeof(enTeteImageBMP), 1, pImage); + printf("Taille en tête : %d\nLargeur : %d\nHauteur : %d\n",enTete.tailleEnTete,enTete.largeur,enTete.hauteur); + printf("Nombre de plans : %d\nBits utilisés pp : %d\nCompression : %d\nTaille image : %d\n",enTete.nbPlan,enTete.bitParPixel,enTete.typeCompression,enTete.tailleImage); + printf("Resolution h : %d\nResolution v : %d\nNombre couleurs : %d\nNombre couleurs importantes : %d\n",enTete.resoHorizontale,enTete.resoVerticale,enTete.nbCouleursUtilisees,enTete.nbCouleursImportantes); + +} diff --git a/BTS/C/Premiere annee/modificationImage/biblio.h b/BTS/C/Premiere annee/modificationImage/biblio.h new file mode 100644 index 0000000..e4fbf72 --- /dev/null +++ b/BTS/C/Premiere annee/modificationImage/biblio.h @@ -0,0 +1,48 @@ +#ifndef BIBLIO_H_INCLUDED + +#define BIBLIO_H_INCLUDED +#include +#include +#pragma pack(push, 1) + +typedef struct +{ + unsigned char signature[2]; + unsigned int tailleFichier; + unsigned int reserve; + unsigned int adresseRelative; + +}enTeteFichierBMP; + +typedef struct +{ + unsigned int tailleEnTete; + unsigned int largeur; + unsigned int hauteur; + unsigned short nbPlan; + unsigned short bitParPixel; + unsigned int typeCompression; + unsigned int tailleImage; + unsigned int resoHorizontale; + unsigned int resoVerticale; + unsigned int nbCouleursUtilisees; + unsigned int nbCouleursImportantes; + +}enTeteImageBMP; + +typedef struct +{ + unsigned char bleu; + unsigned char vert; + unsigned char rouge; + unsigned char alpha; +}couleur; + + +void afficheEnTeteFichierBmp(FILE* pImage); + +void afficheEnTeteImageBmp(FILE* pImage); + + + +#endif // BIBLIO_H_INCLUDED diff --git a/BTS/C/Premiere annee/modificationImage/main.c b/BTS/C/Premiere annee/modificationImage/main.c new file mode 100644 index 0000000..4ffad7a --- /dev/null +++ b/BTS/C/Premiere annee/modificationImage/main.c @@ -0,0 +1,58 @@ +#include +#include +#include "biblio.h" +#define NBCOULEURS 256 + +int main(int argc, char *argv[]) +{ + enTeteFichierBMP enTeteFichier; + enTeteImageBMP enTeteImage; + couleur palette[NBCOULEURS]; + int i, retour; + char pixel; + + FILE *pImage = fopen(argv[1], "r"); + + FILE *pImageModif = fopen(argv[2], "w+"); + + if(pImage == NULL){ + printf("Impossible car le premier fichier est invalide.\n"); + exit(0); + } + if(pImageModif == NULL){ + printf("Impossible car le second fichier est invalide.\n"); + exit(0); + } + + afficheEnTeteFichierBmp(pImage); + printf("\n\n"); + afficheEnTeteImageBmp(pImage); + + rewind(pImage); + retour = fread(&enTeteFichier, sizeof(enTeteFichier), 1, pImage); + retour = fwrite(&enTeteFichier, sizeof(enTeteFichier), 1, pImageModif); + retour = fread(&enTeteImage, sizeof(enTeteImage), 1, pImage); + retour = fwrite(&enTeteImage, sizeof(enTeteImage), 1, pImageModif); + + retour = fread(palette, sizeof(couleur), NBCOULEURS, pImage); + + for(i = 0; i < NBCOULEURS; i++) + { + palette[i].bleu = 0; + palette[i].vert = 0; + } + + retour = fwrite(palette, sizeof(couleur), NBCOULEURS, pImageModif); + + //Copie des donnees de l'image + while(!feof(pImage)) + { + retour = fread(&pixel, sizeof(char), 1, pImage); + retour = fwrite(&pixel, sizeof(char), 1, pImageModif); + }; + + retour = fclose(pImage); + retour = fclose(pImageModif); + + return 0; +} diff --git a/BTS/C/Premiere annee/perso1.c b/BTS/C/Premiere annee/perso1.c new file mode 100644 index 0000000..5c1da54 --- /dev/null +++ b/BTS/C/Premiere annee/perso1.c @@ -0,0 +1,48 @@ +#include +#include + +int main() +{ + float reel; + printf("Saisir une valeur réelle: "); + scanf("%f", &reel); + + if(3.14 >= reel && reel <3.16 ) + { + printf("Ok"); + } + + int entier; + printf("Saisir une valeur entière: "); + scanf("%d", &entier); + + if(0 <= entier && entier <= 20) + { + printf("Note ok"); + } + + char caractere; + printf("Saisir un caractère: "); + scanf("%c", &caractere); + if('a' <= caractere && caractere <= 'z') + { + printf("C'est une lettre."); + } + else + { + printf("Ce n'est pas une lettre."); + } + + char caractere; + printf("Saisir un caractère: "); + scanf("%c", &caractere); + if(('a' <= caractere && caractere <= 'z') || ('A' <= caractere && caractere <= 'Z')) + { + printf("C'est une lettre."); + } + else + { + printf("Ce n'est pas une lettre."); + } +} + diff --git a/BTS/C/Premiere annee/pointeur.c b/BTS/C/Premiere annee/pointeur.c new file mode 100644 index 0000000..a282daf --- /dev/null +++ b/BTS/C/Premiere annee/pointeur.c @@ -0,0 +1,25 @@ +#include +#include + +int main() +{ + char *ptrCar; + int *ptrEntier; + float *ptrReel; + char chaine[]="12345678000A"; + int i; + ptrCar = chaine ; + ptrEntier = (int *)chaine ; + ptrReel = (float *)chaine ; + for(i=0;i<3;i++) + { + printf("ptrCar = %X\t*ptrCar = %c\n",ptrCar,*ptrCar); + printf("ptrEntier = %X\t*ptrEntier = %d\n",ptrEntier,*ptrEntier); + printf("ptrReel = %X\t*ptrReel = %f\n",ptrReel,*ptrReel); + + ptrCar++; + ptrEntier++; + ptrReel++; + printf("\n"); + } +} diff --git a/BTS/C/Premiere annee/sano/main.c b/BTS/C/Premiere annee/sano/main.c new file mode 100644 index 0000000..f513802 --- /dev/null +++ b/BTS/C/Premiere annee/sano/main.c @@ -0,0 +1,91 @@ +#include +#include +#include "sao.h" + +int main() +{ + typePersonnage *joueur1 = NULL; + typePersonnage *joueur2 = NULL; + + int choix; + int i; + + do + { + afficherMenu(joueur1, joueur2); + + printf("Votre choix : "); + + scanf("%d", &choix); + + switch(choix) + { + case 1: + if(joueur1 == NULL) + { + joueur1 = creerPersonnage(joueur1); + } + else + { + printf("Vous ne pouvez pas recréer ce personnage.\n"); + } + break; + case 2: + joueur1 = chargerPersonnage(); + break; + case 3: + if(joueur2 == NULL) + { + joueur2 = creerPersonnage(joueur2); + } + else + { + printf("Vous ne pouvez pas recréer ce personnage.\n"); + } + break; + case 4: + joueur2 = chargerPersonnage(); + break; + case 5: + faireUnDuel(joueur1, joueur2); + break; + case 6: + for(i = 0; i < 10; i++) + { + faireUnDuel(joueur1, joueur2); + } + break; + case 7: + faireUnDuel(joueur2, joueur1); + break; + case 8: + for(i = 0; i < 10; i++) + { + faireUnDuel(joueur2, joueur1); + } + break; + case 9: + afficherPersonnage(joueur1); + break; + case 10: + afficherPersonnage(joueur2); + break; + case 11: + sauvegarderPersonnages(joueur1); + break; + case 12: + sauvegarderPersonnages(joueur2); + break; + case 13: + printf("Au revoir.\n"); + break; + default: + printf("Saisie incorrecte.\n"); + break; + } + } + while(choix != 13); + + return 0; +} + diff --git a/BTS/C/Premiere annee/sano/sao.c b/BTS/C/Premiere annee/sano/sao.c new file mode 100644 index 0000000..fd5a4da --- /dev/null +++ b/BTS/C/Premiere annee/sano/sao.c @@ -0,0 +1,793 @@ +/********************************************************************* +Nom du projet : sao +Nom du fichier : sao.c +Auteur : dbernard +Date de création : Friday 2015-12-04-13.57 +------------------------------------------ +Edition : therbron +Date d'edition : Thursday 2015-12-10-13.28 +------------------------------------------ +Copyright 2013 par depinfo.touchard +Description fonctionnelle de la bibliotheque : + + + +*********************************************************************/ + +#include "sao.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// attendre un maxTime millisecondes +void msleep(unsigned int maxTime) +{ + /* + struct timespec { + time_t tv_sec; // secondes + long tv_nsec; // nanosecondes + }; + */ + struct timespec req; + struct timespec rem; + time_t secondes=0; + long nanoSecondes=0; + if (maxTime>=1000) + { + do + { + secondes++; + maxTime-=1000; + } + while(maxTime>=1000); + } + nanoSecondes=maxTime*1000000; + req.tv_sec=secondes; + req.tv_nsec=nanoSecondes; + nanosleep(&req,&rem); + +} + +//retourne une valeur entiere E[0..maxAlea[ +unsigned int aleatoire(unsigned int maxAlea ) +{ + /* struct timeb { + time_t time; + unsigned short millitm; + short timezone; + short dstflag; + };*/ + + struct timeb t; + float a, b ; + unsigned int nbmilli; + ftime( &t ); + nbmilli = t.time * 1000 + t.millitm; + srand( nbmilli ); + a = rand(); + b = ( maxAlea * a ) / RAND_MAX; + msleep(50); + return( ( unsigned int )b ); + + +} + + +void afficherMenu(typePersonnage *joueur1, typePersonnage *joueur2) +{ + if(joueur1 == NULL) + { + printf("1 - Creer personnage joueur 1\n"); + printf("2 - Charger joueur 1\n"); + } + + if(joueur2 == NULL) + { + printf("3 - Creer personnage joueur 2\n"); + printf("4 - Charger joueur 2\n"); + } + + if((joueur1 != NULL) && (joueur2 != NULL)) + { + printf("5 - joueur 1 vs joueur 2\n"); + printf("6 - joueur 1 vs joueur 2 X10\n"); + printf("7 - joueur 2 vs joueur 1\n"); + printf("8 - joueur 2 vs joueur 1 X 10\n"); + printf("9 - Afficher joueur 1\n"); + printf("10 - Afficher joueur 2\n"); + printf("11 - Sauvegarder joueur 1\n"); + printf("12 - Sauvegarder joueur 2\n"); + } + + printf("13 - Quitter\n"); +} + + +int calculAttaque(typePersonnage *att) +{ + double bonus; + double attaque; + switch (att->competence) + { + case PALADIN: + bonus=BONUSATTPALA; + break; + case SAMOURAI: + bonus=BONUSATTSAM; + break; + case BERSERK: + bonus=BONUSATTBER; + break; + case BRETTEUR: + bonus=BONUSATTBRE; + break; + case GUERRIER: + bonus=BONUSATTGUE; + break; + case ASSASSIN: + bonus=BONUSATTASS; + break; + } + + attaque=att->niveau*( (att->poids*att->taille)/ (double)att->age)*bonus; + // je personnage possede une arme a 2 mains + if (att->armes.deuxMains!=NIL) + { + attaque=attaque+att->armes.deuxMains; + } + else // le personnage ne possede pas d'arme a 2 mains + { + // le perso n'a pas de bouclier + if (att->armes.mainDroite!=BOUCLIER && att->armes.mainGauche!=BOUCLIER) + { + attaque=attaque+att->armes.mainDroite+att->armes.mainGauche; + } + else // un bouclier dans l'une des mains + { + attaque=attaque+att->armes.mainDroite+att->armes.mainGauche-BOUCLIER+2; + } + } + attaque=attaque*(0.5+aleatoire(10)/10.0); + return (int)attaque; +} + + +int calculDefense(typePersonnage *def) +{ + double bonus; + double defense; + switch (def->competence) + { + case PALADIN: + bonus=BONUSDEFPALA; + break; + case SAMOURAI: + bonus=BONUSDEFSAM; + break; + case BERSERK: + bonus=BONUSDEFBER; + break; + case BRETTEUR: + bonus=BONUSDEFBRE; + break; + case GUERRIER: + bonus=BONUSDEFGUE; + break; + case ASSASSIN: + bonus=BONUSDEFASS; + break; + } + + defense=def->niveau*( (def->poids*def->taille)/ (double)def->age)*bonus; + // je personnage possede une arme a 2 mains + if (def->armes.deuxMains!=NIL) + { + defense=defense-(def->armes.deuxMains)/2; + } + else // le personnage ne possede pas d'arme a 2 mains + { + // le perso n'a pas de bouclier + if (def->armes.mainDroite!=BOUCLIER && def->armes.mainGauche!=BOUCLIER) + { + defense=defense-(def->armes.mainDroite+def->armes.mainGauche)/3; + } + else // un bouclier dans l'une des mains + { + defense=defense-BOUCLIER; + } + } + defense=defense*(0.5+aleatoire(10)/10.0); + return (int)defense; + +} + + +void mettreAJourNiveau(typePersonnage *perso, unsigned int exp) +{ + perso->experience+=exp; + if (perso->experience>=EXPERIENCEPASSAGE) + { + perso->niveau++; + perso->experience-=EXPERIENCEPASSAGE; + perso->pvMax+=PVMAXINIT/perso->niveau; + perso->pv=perso->pvMax; + switch (perso->competence) + { + case PALADIN: + perso->resistancePhysique+=RESPALADIN; + break; + case SAMOURAI: + perso->resistancePhysique+=RESSAMOURAI; + break; + case BERSERK: + perso->resistancePhysique+=RESBERSERK; + break; + case BRETTEUR: + perso->resistancePhysique+=RESBRETTEUR; + break; + case GUERRIER: + perso->resistancePhysique+=RESGUERRIER; + break; + case ASSASSIN: + perso->resistancePhysique+=RESASSASSIN; + break; + } + } + +} + + +unsigned int calculerGainExperience(typePersonnage *p1,typePersonnage *p2,booleen victoire,unsigned int tours) +{ + unsigned int exp=0; + if (victoire) + { + exp=2*(p2->niveau-p1->niveau+1)*tours; + + } + else + { + exp=(p2->niveau-p1->niveau+1)*tours; + + } + return exp; + +} + + +void afficherClasse(competenceDeClasse c) +{ + switch(c) + { + case PALADIN: + printf("Paladin \n"); + break; + case SAMOURAI: + printf("Samourai\n"); + break; + case BERSERK: + printf("Berserk\n"); + break; + case BRETTEUR: + printf("Bretteur\n"); + break; + case GUERRIER: + printf("Guerrier\n"); + break; + case ASSASSIN: + printf("Assassin\n"); + break; + } +} + + +void afficherArmeUneMain(armesUneMain aum) +{ + switch (aum) + { + case DAGUE: + printf("Dague - degats : %d\n",DAGUE); + break; + case WAKIZASHI: + printf("Wakizashi - degats : %d\n",WAKIZASHI); + break; + case GLAIVE: + printf("Glaive - degats : %d\n",GLAIVE); + break; + case XIPHOS: + printf("Xiphos - degats : %d\n",XIPHOS); + break; + case CLADIO: + printf("Cladio - degats : %d\n",CLADIO); + break; + case RAPIERE: + printf("Rapiere - degats : %d\n",RAPIERE); + break; + case BOUCLIER: + printf("Bouclier - protection : %d\n",-BOUCLIER); + break; + case RIEN: + printf("Vide - degats : 1\n"); + break; + } +} + +void afficherArmeDeuxMains(armesDeuxMains adm) +{ + switch (adm) + { + case NIL: + printf("Nil - degats : %d\n",NIL); + break; + case BATARDE: + printf("Batarde - degats : %d\n",BATARDE); + break; + case KATANA: + printf("Katana - degats : %d\n",KATANA); + break; + case CLAYMORE: + printf("Claymore - degats : %d\n",CLAYMORE); + break; + case FLAMBERGE: + printf("Flamberge - degats : %d\n",FLAMBERGE); + break; + } +} + +void afficherArmement(typeArmement arm) +{ + // il possede une arme a 2 mains + if (arm.deuxMains!=NIL) + { + printf("2 mains : "); + afficherArmeDeuxMains(arm.deuxMains); + } + else + { + printf("Main gauche : "); + afficherArmeUneMain(arm.mainGauche); + printf("Main droite : "); + afficherArmeUneMain(arm.mainDroite); + } +} + + +void afficherPersonnage(typePersonnage *perso) +{ + printf("Classe : "); + afficherClasse(perso->competence); + printf("Nom: %s\nPrenom : %s\nAge : %d\nTaille : %.2f\nPoids : %.2f\n",perso->nom,perso->prenom,perso->age,perso->taille,perso->poids); + printf("Resistance : %d\nPoints de vie : [%d/%d]\n",perso->resistancePhysique,perso->pv,perso->pvMax); + printf("Niveau : %d\nExperience dans le niveau : %d/%d\n",perso->niveau,perso->experience,EXPERIENCEPASSAGE); + afficherArmement(perso->armes); +} + + +armesUneMain choisirArmeUneMain() +{ + armesUneMain arme; + int choix; + do + { + printf("Choix de l'arme :\n"); + printf(" 1 :"); + afficherArmeUneMain(DAGUE); + printf(" 2 :"); + afficherArmeUneMain(WAKIZASHI); + printf(" 3 :"); + afficherArmeUneMain(GLAIVE); + printf(" 4 :"); + afficherArmeUneMain(XIPHOS); + printf(" 5 :"); + afficherArmeUneMain(CLADIO); + printf(" 6 :"); + afficherArmeUneMain(RAPIERE); + printf("\n votre choix : "); + scanf("%d",&choix); + } + while(choix<1 || choix >6); + switch(choix) + { + case 1: + arme=DAGUE; + break; + case 2: + arme=WAKIZASHI; + break; + case 3: + arme=GLAIVE; + break; + case 4: + arme=XIPHOS; + break; + case 5: + arme=CLADIO; + break; + case 6: + arme=RAPIERE; + break; + } + return arme; + +} + + +armesDeuxMains choisirArmeDeuxMains() +{ + armesDeuxMains arme; + int choix; + do + { + printf("Choix de l'arme : \n"); + printf(" 1 :"); + afficherArmeDeuxMains(BATARDE); + printf(" 2 :"); + afficherArmeDeuxMains(KATANA); + printf(" 3 :"); + afficherArmeDeuxMains(CLAYMORE); + printf(" 4 :"); + afficherArmeDeuxMains(FLAMBERGE); + printf("\n votre choix : "); + scanf("%d",&choix); + } + while(choix<1 || choix >4); + switch(choix) + { + case 1: + arme=BATARDE; + break; + case 2: + arme=KATANA; + break; + case 3: + arme=CLAYMORE; + break; + case 4: + arme=FLAMBERGE; + break; + } + return arme; + +} + + +unsigned int determinerResistance(competenceDeClasse c) +{ + unsigned int res; + + switch(c) + { + case PALADIN: + res=RESPALADIN; + break; + case SAMOURAI: + res=RESSAMOURAI; + break; + case BERSERK: + res=RESBERSERK; + break; + case BRETTEUR: + res=RESBRETTEUR; + break; + case GUERRIER: + res=RESGUERRIER; + break; + case ASSASSIN: + res=RESASSASSIN; + break; + } + return res; +} + + +typePersonnage* creerPersonnage() +{ + typePersonnage* p=malloc(sizeof(typePersonnage)); + int choix; + char unOuDeux; + do + { + printf("choix de la classe :\n"); + printf(" 1 - Bretteur\n"); + printf(" 2 - Paladin\n"); + printf(" 3 - Berserk\n"); + printf(" 4 - Assassin\n"); + printf(" 5 - Guerrier\n"); + printf(" 6 - Samourai\n"); + printf("Votre choix : "); + scanf("%d",&choix); + } + while(choix<1 || choix >6); + + switch (choix) + { + case 1: + p->competence=BRETTEUR; + break; + case 2: + p->competence=PALADIN; + break; + case 3: + p->competence=BERSERK; + break; + case 4: + p->competence=ASSASSIN; + break; + case 5: + p->competence=GUERRIER; + break; + case 6: + p->competence=SAMOURAI; + break; + } + printf("Nom :"); + scanf(" %s",p->nom); + printf("Prenom :"); + scanf(" %s",p->prenom); + printf("Age :"); + scanf("%d",&p->age); + printf("Taille :"); + scanf("%f",&p->taille); + printf("Poids :"); + scanf("%f",&p->poids); + + + p->pv=PVMAXINIT; + p->pvMax=PVMAXINIT; + p->experience=0; + p->niveau=1; + + p->resistancePhysique=determinerResistance(p->competence); + // si berserk ne peut avoir qu'une arme a 2 mains + if (p->competence==BERSERK) + { + + p->armes.deuxMains=choisirArmeDeuxMains(); + } + else // pas berserk + { + p->armes.deuxMains=NIL; + if (p->competence==PALADIN || p->competence==SAMOURAI) + { + do + { + printf("Voulez vous utiliser une arme à deux mains(o/n)?"); + scanf(" %c",&unOuDeux); + + } + while(unOuDeux!='o' && unOuDeux!='n' ); + if (unOuDeux=='o') + { + p->armes.deuxMains=choisirArmeDeuxMains(); + + } + else + { + p->armes.mainDroite=choisirArmeUneMain(); + + if (p->competence==PALADIN) // epee et bouclier + { + + p->armes.mainGauche=BOUCLIER; + + } + if (p->competence==SAMOURAI) // epee et main libre + { + + p->armes.mainGauche=RIEN; + + } + + } + } + if (p->competence==ASSASSIN) + { + p->armes.mainDroite=choisirArmeUneMain(); + p->armes.mainGauche=RIEN; + + } + if (p->competence==BRETTEUR) + { + do + { + printf("Voulez vous utiliser deux armes (o/n)?"); + scanf(" %c",&unOuDeux); + + } + while(unOuDeux!='o' && unOuDeux!='n' ); + if (unOuDeux=='o') + { + printf("Main droite : "); + p->armes.mainDroite=choisirArmeUneMain(); + printf("Main gauche : "); + p->armes.mainGauche=choisirArmeUneMain(); + } + else + { + p->armes.mainDroite=choisirArmeUneMain(); + + p->armes.mainGauche=RIEN; + + } + + } + if (p->competence==GUERRIER) + { + do + { + printf("Voulez vous utiliser un bouclier(o/n)?"); + scanf(" %c",&unOuDeux); + + } + while(unOuDeux!='o' && unOuDeux!='n' ); + if (unOuDeux=='o') + { + printf("Main droite : "); + p->armes.mainDroite=choisirArmeUneMain(); + + p->armes.mainGauche=BOUCLIER; + } + else + { + p->armes.mainDroite=choisirArmeUneMain(); + + p->armes.mainGauche=RIEN; + + } + + } + + } + + return p; +} + + +void faireUnDuel(typePersonnage *j1,typePersonnage *j2) +{ + booleen j1gagne=FALSE; + booleen j2gagne=FALSE; + int tour=0; + int expj1,expj2; + int degatJ1vsJ2; + int degatJ2vsJ1; + + do + { + degatJ1vsJ2=calculDegats(j1,j2); +// mettre a jour les pv de j2 (pv actuel - degat) + + j2->pv = j2->pv - degatJ1vsJ2; + +// afficher j1 attaque j2 et degats occasionnes + + printf("Le joueur 1 attaque le joueur 2 et lui inflige %d de degats.\n", degatJ1vsJ2); + + degatJ2vsJ1=calculDegats(j2,j1); +// mettre a jour les pv de j1 (pv actuel - degat) + + j1->pv = j1->pv - degatJ2vsJ1; + +// afficher j1 attaque j2 et degats occasionnes + + printf("Le joueur 2 attaque le joueur 1 et lui inflige %d de degats.\n", degatJ2vsJ1); + +// afficher les pv des deux joueurs + + printf("%s [%d/%d]pv\n", j1->nom, j1->pv, j1->pvMax); + printf("%s [%d/%d]pv\n", j2->nom, j2->pv, j1->pvMax); + +// augmenter le nombre de tours + + tour++; + } + while (j1->pv>0 && j2->pv>0); + + if (j1->pv>0) + { + j1gagne=TRUE; +// remettre les pv de j2 au maximum + + j2->pv = j2->pvMax; + + } + else + { + j2gagne=TRUE; +// remettre les pv de j1 au maximum + + j1->pv = j1->pvMax; + + } + + expj1 = calculerGainExperience(j1,j2,j1gagne,tour); +// mettre a jour j1 + + mettreAJourNiveau(j1, expj1); + + expj2 = calculerGainExperience(j2,j1,j2gagne,tour); +// mettre a jour j2 + + mettreAJourNiveau(j2, expj2); + +// afficher j1 + + printf("++++++++++++++++++++++++++++++++"); + + afficherPersonnage(j1); + + printf("================================="); +// afficher j2 + + afficherPersonnage(j2); + + printf("++++++++++++++++++++++++++++++++"); + +} + + +int calculDegats(typePersonnage *attaquant, typePersonnage *defenseur) +{ + float degats; + + degats = calculAttaque(attaquant) - calculDefense(defenseur); + + if(degats <= 0){ + degats = 1; + } + + return degats; +} + + +void sauvegarderPersonnages(typePersonnage *joueur) +{ + char nomFichier[NBMAXCARNOM]; + + printf("Nom du fichier txt de sauvegarde :"); + scanf("%s", nomFichier); + + FILE *pFich = fopen(nomFichier, "w+"); + + //Test si le fichier est correcte + if(pFich == -1) + { + printf("%s\n", strerror(errno)); + exit(errno); + } + + fwrite(joueur, sizeof(typePersonnage), 1, pFich); + + fclose(pFich); +} + + +typePersonnage* chargerPersonnage() +{ + char nomFichier[NBMAXCARNOM]; + typePersonnage* joueur=malloc(sizeof(typePersonnage)); + + printf("Nom du fichier txt à ouvrir \n(le fichier en question doit etre a la racine du programme):"); + scanf("%s", nomFichier); + + FILE *pFich = fopen(nomFichier, "r"); + + //Test si le fichier est correcte + if(pFich == -1) + { + printf("%s\n", strerror(errno)); + exit(errno); + } + + fread(joueur, sizeof(typePersonnage), 1, pFich); + + fclose(pFich); + + return joueur; +} diff --git a/BTS/C/Premiere annee/sano/sao.h b/BTS/C/Premiere annee/sano/sao.h new file mode 100644 index 0000000..e71324c --- /dev/null +++ b/BTS/C/Premiere annee/sano/sao.h @@ -0,0 +1,103 @@ +#ifndef SAO_H_INCLUDED +#define SAO_H_INCLUDED + +#define NBMAXCARNOM 50 +#define NBMAXCARPRENOM 50 +#define EXPERIENCEPASSAGE 200 +#define PVMAXINIT 500 + +#define RESBRETTEUR 20 +#define RESPALADIN 15 +#define RESBERSERK 5 +#define RESASSASSIN 25 +#define RESGUERRIER 10 +#define RESSAMOURAI 15 + +#define BONUSDEFPALA 1.5 +#define BONUSDEFSAM 1.5 +#define BONUSDEFBER 0.5 +#define BONUSDEFBRE 1.5 +#define BONUSDEFGUE 1 +#define BONUSDEFASS 3 + +#define BONUSATTPALA 1.5 +#define BONUSATTSAM 1.5 +#define BONUSATTBER 3 +#define BONUSATTBRE 1.75 +#define BONUSATTGUE 1 +#define BONUSATTASS 0.5 + +typedef enum +{ + FALSE=0, TRUE +}booleen; + +/*definition du type enum competenceDeClasse*/ + +typedef enum +{ + BRETTEUR=1, PALADIN, BERSERK, ASSASSIN, GUERRIER, SAMOURAI +} competenceDeClasse; + +typedef enum +{ + BOUCLIER=-10, RIEN=0, DAGUE=5,WAKIZASHI=8,GLAIVE=10, XIPHOS=11, CLADIO=12, RAPIERE=13 + +} armesUneMain; + +typedef enum +{ + NIL=0, BATARDE=25, KATANA=30, CLAYMORE=32, FLAMBERGE=35 +} armesDeuxMains; + +/*definition du type structure typeArmement*/ + +typedef struct +{ + armesUneMain mainGauche; + armesUneMain mainDroite; + armesDeuxMains deuxMains; +}typeArmement; + +typedef struct +{ + char nom[NBMAXCARNOM]; + char prenom[NBMAXCARPRENOM]; + unsigned int age; + float taille; + float poids; + int resistancePhysique; + int pv; + unsigned int pvMax; + unsigned int niveau; + unsigned int experience; + competenceDeClasse competence; + typeArmement armes; +} typePersonnage; + +void msleep(unsigned int maxTime); +unsigned int aleatoire(unsigned int maxAlea ); + +int calculAttaque(typePersonnage *att); +int calculDefense(typePersonnage *def); +void mettreAJourNiveau(typePersonnage *perso, unsigned int exp); +unsigned int calculerGainExperience(typePersonnage *p1,typePersonnage *p2, booleen victoire,unsigned int tours); +void afficherClasse(competenceDeClasse c); +void afficherArmeDeuxMains(armesDeuxMains adm); +void afficherArmement(typeArmement arm); +armesUneMain choisirArmeUneMain(); +armesDeuxMains choisirArmeDeuxMains(); +unsigned int determinerResistance(competenceDeClasse classe); +typePersonnage* creerPersonnage(); +void faireUnDuel(typePersonnage *j1,typePersonnage *j2); + +/*déclaration des fonctions à faire*/ + +void afficherPersonnage(typePersonnage *joueur); +void afficherMenu(typePersonnage *joueur1, typePersonnage *joueur2); +typePersonnage* chargerPersonnage(); +void sauvegarderPersonnages(typePersonnage *joueur); +int calculDegats(typePersonnage *attaquant, typePersonnage *defenseur); + +#endif // SAO_H_INCLUDED + diff --git a/BTS/C/Premiere annee/serialConnection.c b/BTS/C/Premiere annee/serialConnection.c new file mode 100644 index 0000000..16116d7 --- /dev/null +++ b/BTS/C/Premiere annee/serialConnection.c @@ -0,0 +1,78 @@ +#include +#include +#include +#include +#include +#include +#include + +int main() +{ + int fd; + int retour; + char str[255]; + + struct termios tty, orig; + tty.c_iflag = IGNBRK | IGNPAR; + tty.c_oflag = 0; + tty.c_cflag = B9600 | CS8 | CLOCAL | CREAD | IGNPAR | CSTOP; + tty.c_cflag &= ~PARENB; + tty.c_cflag &= ~CRTSCTS; + tty.c_lflag &= ~ICANON; + tty.c_lflag &= ~ECHO; + tty.c_cc[VMIN] = 0; + tty.c_cc[VTIME] = 1; + + //Ouverture de la liaison serie + fd = open("/dev/ttyS0", O_RDWR); + if(fd == -1) + { + printf("Probleme d'ouverture : %s\n", strerror(errno)); + exit(errno); + } + + /*traitement, lecture/ecriture*/ + //fermeture du port + if(retour == -1) + { + printf("Probleme de fermeture : %s\n", strerror(errno)); + exit(errno); + } + + /* Lecture et sauvegarde des parametres courants */ + tcgetattr(fd,&tty); + orig=tty; + /* remplissage des champs de la structure termios*/ + + /* appplication des nouveaux parametres */ + if(tcsetattr(fd,TCSANOW,&tty)<0) + { + printf ("impossible d'initialiser le port série\n"); + } + + /* lecture/ecriture/traitement sur la liaison série */ + + do{ + printf("Que voulez-vous envoyer ?\n"); + gets(str); + + write(fd, str, strlen(str)); + + printf("%s a ete envoye.\n", str); + + }while(1); + + /* on remet l'etat initiale de la configuration du port*/ + if(tcsetattr(fd,TCSANOW,&orig)<0) + { + printf ("impossible d'initialiser le port série\n"); + } + /* Fermeture port série*/ + retour=close(fd); + if ( retour == -1 ) + { + printf("pb fermeture: %s\n",strerror(errno)); + exit(errno); + } + return 0; +} diff --git a/BTS/C/Premiere annee/stegano/biblio.c b/BTS/C/Premiere annee/stegano/biblio.c new file mode 100644 index 0000000..0c7975a --- /dev/null +++ b/BTS/C/Premiere annee/stegano/biblio.c @@ -0,0 +1,23 @@ +#include "biblio.h" + +void afficherSteganoTxt(char nomFichier[], int pas) +{ + char phraseMystere[TAILLEMAX]; + int i = 0; + + FILE *imageTxtCache = fopen(nomFichier, "r+"); + + if(imageTxtCache == NULL){ + printf("Impossible car le premier fichier est invalide.\n"); + exit(0); + } + + fseek(imageTxtCache, 1078, SEEK_SET); + + while(fread(&phraseMystere[i], sizeof(char), 1, imageTxtCache) == 1) + { + i += pas; + } + + printf("%s", phraseMystere); +} diff --git a/BTS/C/Premiere annee/stegano/biblio.h b/BTS/C/Premiere annee/stegano/biblio.h new file mode 100644 index 0000000..2545a7f --- /dev/null +++ b/BTS/C/Premiere annee/stegano/biblio.h @@ -0,0 +1,11 @@ +#ifndef BIBLIO_H_INCLUDED +#define BIBLIO_H_INCLUDED + +#include +#include + +#define TAILLEMAX 50 + +void afficherSteganoTxt(char nomFichier[], int pas); + +#endif // BIBLIO_H_INCLUDED diff --git a/BTS/C/Premiere annee/stegano/main.c b/BTS/C/Premiere annee/stegano/main.c new file mode 100644 index 0000000..d8dc4d3 --- /dev/null +++ b/BTS/C/Premiere annee/stegano/main.c @@ -0,0 +1,6 @@ +#include "biblio.h" + +int main(int argc, char *argv[]) +{ + afficherSteganoTxt(argv[1], argv[2]); +} diff --git a/BTS/C/Premiere annee/structure/biblio.c b/BTS/C/Premiere annee/structure/biblio.c new file mode 100644 index 0000000..23def5a --- /dev/null +++ b/BTS/C/Premiere annee/structure/biblio.c @@ -0,0 +1,29 @@ +#include +#include +#include "biblio.h" + +typePersonne creePersonnePtr(){ + typePersonne *personne; + + personne = (typePersonne*) malloc(sizeof(typePersonne)); + + printf("Quel est votre prenom ?\n"); + scanf("%s", personne->prenom); + printf("Quel est votre nom ?\n"); + scanf("%s", personne->nom); + printf("Quel est votre date de naissance ?\n"); + scanf("%u", &personne->annee); + printf("Quel est votre taille ?\n"); + scanf("%f", &personne->taille); + printf("Quel est votre poids ?\n"); + scanf("%f", &personne->poids); + + return *personne; +} + +void affichePersonnePtr(typePersonne personne){ + printf("Votre nom est %s %s.\n", personne.nom, personne.prenom); + printf("Votre année de naissance est %u.\n", personne.annee); + printf("Votre taille est de %.2f.\n", personne.taille); + printf("Votre poids est de %.2f.\n", personne.poids); +} diff --git a/BTS/C/Premiere annee/structure/biblio.h b/BTS/C/Premiere annee/structure/biblio.h new file mode 100644 index 0000000..663a855 --- /dev/null +++ b/BTS/C/Premiere annee/structure/biblio.h @@ -0,0 +1,17 @@ +#ifndef BIBLIO_H_INCLUDED +#define BIBLIO_H_INCLUDED +#define TAILLEMAX 50 + +typedef struct{ + char nom[TAILLEMAX]; + char prenom[TAILLEMAX]; + unsigned int annee; + float taille; + float poids; +}typePersonne; + +typePersonne creePersonnePtr(); + +void affichePersonnePtr(typePersonne personne); + +#endif // BIBLIO_H_INCLUDED diff --git a/BTS/C/Premiere annee/structure/main.c b/BTS/C/Premiere annee/structure/main.c new file mode 100644 index 0000000..ee5fdd7 --- /dev/null +++ b/BTS/C/Premiere annee/structure/main.c @@ -0,0 +1,9 @@ +#include +#include +#include "biblio.h" + +int main() +{ + affichePersonnePtr(creePersonnePtr()); + return 0; +} diff --git a/BTS/C/Premiere annee/structureClub/biblio.c b/BTS/C/Premiere annee/structureClub/biblio.c new file mode 100644 index 0000000..b0cdd48 --- /dev/null +++ b/BTS/C/Premiere annee/structureClub/biblio.c @@ -0,0 +1,39 @@ +#include +#include +#include +#include "biblio.h" + +typeAdherent *nouvelAdherent(){ + typeAdherent *adherent; + + adherent = (typeAdherent*) malloc(sizeof(typeAdherent)); + + printf("Nom: "); + scanf("%s", adherent->nom); + printf("Prenom: "); + scanf("%s", adherent->prenom); + printf("Numero de badge: "); + scanf("%s", adherent->numCarte); + printf("Numero d'activite: "); + scanf("%u", &adherent->numActivite); + + printf("\nVous êtes incrit.\n\n"); + + return adherent; +} + +void afficherUnAdherent(typeAdherent *adherent[], char numCarteAdherent[], int nbAdherent){ + int boucle; + + for(boucle = 0; boucle < nbAdherent; boucle++){ + if(strcmp(adherent[boucle]->numCarte, numCarteAdherent) == 0){ + printf("Nom: "); + printf("%s\n", adherent[boucle]->nom); + printf("Prenom: "); + printf("%s\n", adherent[boucle]->prenom); + printf("Numero d'activite: "); + printf("%u\n\n", adherent[boucle]->numActivite); + + } + } +} diff --git a/BTS/C/Premiere annee/structureClub/biblio.h b/BTS/C/Premiere annee/structureClub/biblio.h new file mode 100644 index 0000000..9efba8f --- /dev/null +++ b/BTS/C/Premiere annee/structureClub/biblio.h @@ -0,0 +1,16 @@ +#ifndef BIBLIO_H_INCLUDED +#define BIBLIO_H_INCLUDED +#define TAILLEMAX 50 + +typedef struct{ + char nom[TAILLEMAX]; + char prenom[TAILLEMAX]; + char numCarte[TAILLEMAX]; + unsigned int numActivite; +}typeAdherent; + +typeAdherent *nouvelAdherent(); + +void afficherUnAdherent(typeAdherent *adherent[], char numCarteAdherent[], int indiceAdherent); + +#endif // BIBLIO_H_INCLUDED diff --git a/BTS/C/Premiere annee/structureClub/main.c b/BTS/C/Premiere annee/structureClub/main.c new file mode 100644 index 0000000..8ccb815 --- /dev/null +++ b/BTS/C/Premiere annee/structureClub/main.c @@ -0,0 +1,52 @@ +#include +#include +#include +#include "biblio.h" +#define NBINSCRITMAX 5000 +#define TAILLEMAX 50 + +int main() +{ + int choix; + int boucle; + char numCarteAdherent[TAILLEMAX]; + int indiceAdherent=0; + + typeAdherent *adherent[NBINSCRITMAX];// = (typeAdherent*) malloc(NBINSCRITMAX*(sizeof(typeAdherent))); + + printf("Bienvenue au club de tennis du Mans.\n\n"); + + do{ + printf("Que voulez-vous faire ?\n"); + printf("1- M'inscrire\n"); + printf("2- Afficher un adhérent en particulier\n"); + printf("3- Quitter\n"); + printf("Votre choix : "); + scanf("%d", &choix); + + switch (choix){ + case 1: + adherent[indiceAdherent] = nouvelAdherent(); + indiceAdherent++; + break; + case 2: + printf("\nQuel adhérent voulez-vous afficher ?"); + scanf("%s", numCarteAdherent); + afficherUnAdherent(adherent, numCarteAdherent, indiceAdherent); + break; + case 3: + printf("\nAu revoir.\n"); + break; + default: + printf("\nChoix inccorecte.\n"); + break; + } + }while(choix < 3); + + //liberation de la memoire + for(boucle = 0; boucle < indiceAdherent; boucle++){ + free(adherent[boucle]); + } + + return 0; +} diff --git a/BTS/C/Premiere annee/structureComplexeSportif/biblio.c b/BTS/C/Premiere annee/structureComplexeSportif/biblio.c new file mode 100644 index 0000000..4453490 --- /dev/null +++ b/BTS/C/Premiere annee/structureComplexeSportif/biblio.c @@ -0,0 +1,375 @@ +#include +#include +#include +#include +#include "biblio.h" + +void effacerEcran() +{ + printf("%c[2J", 0x1B); + printf("\033[100A"); + printf("\033[100D", 0x1B); + printf("BASE DE DONNEE COMPLEXE SPORTIF\n\n"); +} + +void testerOuvertureFichier() +{ + if(errno != NULL) + { + printf("Erreur fichier : erreur n'%d\n", errno); + exit(0); + } +} + +void afficherMenu(int compteurAdherent) +{ + printf("Que voulez-vous faire ?\n"); + + if(compteurAdherent == 0) + { + printf("A- Ajouter une fiche adherent\n"); + printf("Q- Quitter\n"); + } + else + { + printf("A : Ajouter une fiche adherent\n"); + printf("S : Supprimer une fiche\n"); + printf("M : Modifier une fiche\n"); + printf("V : Voir le contenu d'une fiche\n"); + printf("L : Voir le contenu de l'ensemble des fiches\n"); + printf("E : Supprimer toutes les fiches\n"); + printf("X : Exporter adherents\n"); + printf("Q : Quitter\n"); + } + printf("Votre choix :"); +} + +void afficherDate(date dateAfficher) +{ + printf("%d/%d/%d", dateAfficher.jour, dateAfficher.mois, dateAfficher.annee); +} + +void afficherActivite(sport listSport) +{ + switch (listSport) + { + case NATATION: + printf("Natation\n"); + break; + case BASKETBALL: + printf("Basketball\n"); + break; + case HANDBALL: + printf("Handball\n"); + break; + case SQUASH: + printf("Squash\n"); + break; + case TENNIS: + printf("Tennis\n"); + break; + } +} + +typeAdherent *creerUnAdherent() +{ + typeAdherent *adherent; + int i, numSport; + + adherent = (typeAdherent*) malloc(sizeof(typeAdherent)); + printf("Nom :"); + scanf("%s", adherent->nom); + printf("Prenom :"); + scanf("%s", adherent->prenom); + printf("Date de naissance :"); + printf("\n\tJour :"); + scanf("%d", &adherent->dateDeNaissance.jour); + printf("\tMois :"); + scanf("%d", &adherent->dateDeNaissance.mois); + printf("\tAnnee :"); + scanf("%d", &adherent->dateDeNaissance.annee); + printf("Numero d'adherent :"); + scanf("%d", &adherent->numCarte); + printf("Nombre d'activite :"); + scanf("%d", &adherent->nbActivite); + for(i = 0; i < adherent->nbActivite; i++) + { + printf("Quel sport voulez-vous faire ?\n"); + printf("1- Natation\n"); + printf("2- Basket\n"); + printf("3- Hand\n"); + printf("4- Squash\n"); + printf("5- Tennis\n"); + printf("Votre choix : "); + scanf("%d", &numSport); + + switch (numSport) + { + case 1: + adherent->activite[i] = NATATION; + break; + case 2: + adherent->activite[i] = BASKETBALL; + break; + case 3: + adherent->activite[i] = HANDBALL; + break; + case 4: + adherent->activite[i] = SQUASH; + break; + case 5: + adherent->activite[i] = TENNIS; + break; + } + } + return adherent; +} + +void afficherUnAdherent(typeAdherent *adherent[], int numeroCarte, int nb) +{ + int i, j; + for(j = 0; j < nb; j++) + { + if(numeroCarte == adherent[j]->numCarte) + { + printf("\nNom : %s", adherent[j]->nom); + printf("\nPrenom : %s", adherent[j]->prenom); + printf("\nDate de naissance : %d/%d/%d", adherent[j]->dateDeNaissance.jour, adherent[j]->dateDeNaissance.mois, adherent[j]->dateDeNaissance.annee); + printf("\nNombre d'activite : %d\n", adherent[j]->nbActivite); + for(i = 0; i < adherent[j]->nbActivite; i++) + { + afficherActivite(adherent[j]->activite[i]); + } + } + } +} + +void afficherAdherents(typeAdherent *ad[], int nb) +{ + int i, j; + printf("╔════════════════════╦════════════════════╦══════════╦═══════════════════════════════════╗\n"); + printf("║Nom ║Prenom ║Naissance ║Activités ║\n"); + for(j = 0; j < nb; j++) + { + printf("╠════════════════════╬════════════════════╬══════════╬═══════════════════════════════════╣\n"); + printf("║%20s", ad[j]->nom); + printf("║%20s", ad[j]->prenom); + printf("║%2d/%2d/%2d║", ad[j]->dateDeNaissance.jour, ad[j]->dateDeNaissance.mois, ad[j]->dateDeNaissance.annee); + for(i = 0; i < ad[j]->nbActivite; i++) + { + switch (ad[j]->activite[i]) + { + case NATATION: + printf("Natation "); + break; + case BASKETBALL: + printf("Basket "); + break; + case HANDBALL: + printf("Hand "); + break; + case SQUASH: + printf("Squash "); + break; + case TENNIS: + printf("Tennis "); + break; + } + } + printf("\033[100D"); + printf("\033[89C"); + printf("║\n"); + } + printf("╚════════════════════╩════════════════════╩══════════╩═══════════════════════════════════╝\n"); +} + +int ajouterUnAdherent(typeAdherent *tab[], int nb) +{ + tab[nb] = creerUnAdherent(); + nb++; + return nb; +} + +int supprimerUnAdherent(typeAdherent *tab[], int nro, int nb) +{ + int i, j; + + for(i = 0; i < nb; i++) + { + if(tab[i]->numCarte == nro) + { + //free(tab[i]); + + for(j = i; j < nb; j++) + { + tab[j] = tab[j+1]; + } + } + } + nb--; + return nb; +} + +int supprimerAdherents(typeAdherent *tab[], int nb) +{ + int i; + + for(i = 0; i < nb; i++) + { + free(tab[i]); + } + return 0; +} + +void modifierFiche(typeAdherent *tab[], int nro, int nb) +{ + int i; + int choix; + + for(i = 0; i < nb; i++) + { + if(tab[i]->numCarte == nro) + { + do + { + printf("Quel paramètre voulez-vous modifier ?\n"); + printf("1- Nom\n"); + printf("2- Prenom\n"); + printf("3- Date de naissance\n"); + printf("4- Nombre d'activité\n"); + printf("5- Quitter\n"); + printf("Votre choix :"); + scanf("%d", &choix); + + switch (choix) + { + case 1: + printf("Nouveau nom :"); + scanf("%s", tab[i]->nom); + break; + case 2: + printf("Nouveau prenom :"); + scanf("%s", tab[i]->prenom); + break; + case 3: + printf("Nouveau jour de naissance :"); + scanf("%d", &tab[i]->dateDeNaissance.jour); + printf("Nouveau mois de naissance :"); + scanf("%d", &tab[i]->dateDeNaissance.mois); + printf("Nouvelle annee de naissance :"); + scanf("%d", &tab[i]->dateDeNaissance.annee); + break; + case 4: + printf("Nouveau nombre d'activite :"); + scanf("%d", &tab[i]->nbActivite); + break; + } + } + while(choix != 5); + } + } +} + +void sauvegardeAdherents(typeAdherent *ad[], int nb) +{ + char nomFichier[TAILLEMAX]; + + printf("Nom du fichier de sauvegarde :"); + scanf("%s", nomFichier); + strcat(nomFichier, ".txt"); + + FILE *pFich = fopen(nomFichier, "w+"); + testerOuvertureFichier(); + int i, j; + for(j = 0; j < nb; j++) + { + fprintf(pFich, "%d ", ad[j]->numCarte); + fprintf(pFich, "%s ", ad[j]->nom); + fprintf(pFich, "%s ", ad[j]->prenom); + fprintf(pFich, "%d %d %d ", ad[j]->dateDeNaissance.jour, ad[j]->dateDeNaissance.mois, ad[j]->dateDeNaissance.annee); + fprintf(pFich, "%d ", ad[j]->nbActivite); + for(i = 0; i < ad[j]->nbActivite; i++) + { + switch (ad[j]->activite[i]) + { + case NATATION: + fprintf(pFich, "NATATION "); + break; + case BASKETBALL: + fprintf(pFich, "BASKETBALL "); + break; + case HANDBALL: + fprintf(pFich, "HANDBALL "); + break; + case SQUASH: + fprintf(pFich, "SQUASH "); + break; + case TENNIS: + fprintf(pFich, "TENNIS "); + break; + } + } + fprintf(pFich, "\n"); + } + fclose(pFich); +} + +int chargerAdherents(typeAdherent *ad[], int nb) +{ + int i; + char nomFichier[TAILLEMAX]; + char tempoSport[TAILLEMAX]; + + printf("Nom du fichier txt à ouvrir :"); + scanf("%s", nomFichier); + + strcat(nomFichier, ".txt"); + + FILE *pFich = fopen(nomFichier, "r"); + testerOuvertureFichier(); + + while(!feof(pFich)) + { + nb++; + ad[nb] = (typeAdherent*) malloc(sizeof(typeAdherent)); + fscanf(pFich, "%d %s %s %d %d %d %d", &ad[nb]->numCarte, ad[nb]->nom, ad[nb]->prenom, &ad[nb]->dateDeNaissance.jour, + &ad[nb]->dateDeNaissance.mois, &ad[nb]->dateDeNaissance.annee, &ad[nb]->nbActivite); + printf("%d\n", ad[nb]->nbActivite); + for(i = 0; i < ad[nb]->nbActivite; i++) + { + fscanf(pFich, "%s", tempoSport); + if(strcmp(tempoSport, "NATATION")) + { + ad[nb]->activite[i] = NATATION; + } + else + { + if(strcmp(tempoSport, "BASKETBALL")) + { + ad[nb]->activite[i] = BASKETBALL; + } + else + { + if(strcmp(tempoSport, "HANDBALL")) + { + ad[nb]->activite[i] = HANDBALL; + } + else + { + if(strcmp(tempoSport, "SQUASH")) + { + ad[nb]->activite[i] = SQUASH; + } + else{ + if(strcmp(tempoSport, "TENNIS")) + { + ad[nb]->activite[i] = TENNIS; + } + } + } + } + } + } + } + return nb; +} diff --git a/BTS/C/Premiere annee/structureComplexeSportif/biblio.h b/BTS/C/Premiere annee/structureComplexeSportif/biblio.h new file mode 100644 index 0000000..bb37d0d --- /dev/null +++ b/BTS/C/Premiere annee/structureComplexeSportif/biblio.h @@ -0,0 +1,53 @@ +#ifndef BIBLIO_H_INCLUDED +#define BIBLIO_H_INCLUDED +#define NBSPORT 5 +#define TAILLEMAX 50 + +typedef enum{ + NATATION, + BASKETBALL, + HANDBALL, + SQUASH, + TENNIS +}sport; + +typedef struct{ + int jour; + int mois; + int annee; +}date; + +typedef struct{ + char nom[TAILLEMAX]; + char prenom[TAILLEMAX]; + date dateDeNaissance; + int nbActivite; + sport activite[NBSPORT]; + int numCarte; +}typeAdherent; + +void effacerEcran(); + +void afficherMenu(int compteurAdherent); + +void afficherDate(date dateAfficher); + +void afficherActivite(sport listSport); + +typeAdherent *creerUnAdherent(); + +void afficherUnAdherent(typeAdherent *adherent[], int numeroCarte, int nb); + +void afficherAdherents(typeAdherent *ad[], int nb); + +int ajouterUnAdherent(typeAdherent *tab[], int nb); + +int supprimerUnAdherent(typeAdherent *tab[], int nro, int nb); + +int supprimerAdherents(typeAdherent *tab[], int nb); + +void modifierFiche(typeAdherent *tab[], int nro, int nb); + +int chargerAdherents(typeAdherent *ad[], int nb); + +#endif // BIBLIO_H_INCLUDED diff --git a/BTS/C/Premiere annee/structureComplexeSportif/main.c b/BTS/C/Premiere annee/structureComplexeSportif/main.c new file mode 100644 index 0000000..f734a3f --- /dev/null +++ b/BTS/C/Premiere annee/structureComplexeSportif/main.c @@ -0,0 +1,68 @@ +#include +#include +#include "biblio.h" +#define NBADHERENT 5000 + +int main() +{ + typeAdherent **tabAdherent; + int compteurAdherent = 0; + int numeroCarte; + char choix; + printf("BASE DE DONNEE COMPLEXE SPORTIF\n\n"); + + do{ + + afficherMenu(compteurAdherent); + scanf(" %c", &choix); + switch (choix){ + case 'a': + effacerEcran(); + tabAdherent = (typeAdherent**) realloc(tabAdherent, sizeof(typeAdherent)); + compteurAdherent = ajouterUnAdherent(tabAdherent, compteurAdherent); + break; + case 's': + effacerEcran(); + printf("Numero de carte de l'adherent a supprimer :"); + scanf("%d", &numeroCarte); + compteurAdherent = supprimerUnAdherent(tabAdherent, numeroCarte, compteurAdherent); + break; + case 'm': + effacerEcran(); + printf("Numero de carte de l'adherent :"); + scanf("%d", &numeroCarte); + modifierFiche(tabAdherent, numeroCarte, compteurAdherent); + break; + case 'v': + effacerEcran(); + printf("Numero de carte de l'adherent :"); + scanf("%d", &numeroCarte); + afficherUnAdherent(tabAdherent, numeroCarte, compteurAdherent); + break; + case 'l': + effacerEcran(); + afficherAdherents(tabAdherent, compteurAdherent); + break; + case 'e': + effacerEcran(); + compteurAdherent = supprimerAdherents(tabAdherent, compteurAdherent); + break; + case 'x': + effacerEcran(); + sauvegardeAdherents(tabAdherent, compteurAdherent); + break; + case 'c': + effacerEcran(); + compteurAdherent = chargerAdherents(tabAdherent, compteurAdherent); + break; + case 'q': + break; + default: + printf("Saisie incorrecte."); + break; + } + }while(choix != 'q'); + + + return 0; +} diff --git a/BTS/C/Premiere annee/tabDimmension.c b/BTS/C/Premiere annee/tabDimmension.c new file mode 100644 index 0000000..38b1600 --- /dev/null +++ b/BTS/C/Premiere annee/tabDimmension.c @@ -0,0 +1,23 @@ +#include +#include +#define NBCOL 5 +#define NBLIGNE 3 + +int main() +{ + int tab[NBCOL][NBLIGNE]; + int boucleLigne, boucleColonne, modification = 0; + for(boucleLigne = 0; boucleLigne < NBLIGNE; boucleLigne++){ + for(boucleColonne = 0; boucleColonne < NBCOL; boucleColonne++){ + tab[boucleColonne][boucleLigne] = modification; + modification++; + } + } + for(boucleLigne = 0; boucleLigne < NBLIGNE; boucleLigne++){ + for(boucleColonne = 0; boucleColonne < NBCOL; boucleColonne++){ + printf("%d", tab[boucleColonne][boucleLigne]); + } + printf("\n"); + } + return 0; +} diff --git a/BTS/C/Premiere annee/tabDimmensionChaine.c b/BTS/C/Premiere annee/tabDimmensionChaine.c new file mode 100644 index 0000000..eafa34e --- /dev/null +++ b/BTS/C/Premiere annee/tabDimmensionChaine.c @@ -0,0 +1,15 @@ +#include +#include +#define NBMOTS 3 +#define LONGMAXMOT 10 + +int main() +{ + char tabChaine[NBMOTS][LONGMAXMOT]={"coucou", "salut", "hello"}; + int nroMot; + for(nroMot = 0; nroMot < NBMOTS; nroMot++){ + printf("%s", tabChaine[nroMot]); + printf("\n"); + } + return 0; +} diff --git a/BTS/C/Premiere annee/td3v2.c b/BTS/C/Premiere annee/td3v2.c new file mode 100644 index 0000000..42a06a5 --- /dev/null +++ b/BTS/C/Premiere annee/td3v2.c @@ -0,0 +1,25 @@ +#include +#include + +int main() +{ + unsigned int valeur = 0; + int traitement; + unsigned long binaire = 2147483648; + int espacement = 0; + printf("Entrer une valeur entière :"); + scanf("%d", &valeur); + for(traitement = 1; traitement <= 32; traitement++){ + if(valeur >= binaire){ + printf("1"); + valeur = valeur - binaire; + }else{ + printf("0"); + } + binaire = binaire /2; + + if(traitement % 4 == 0){ + printf(" "); + } + } +} diff --git a/BTS/C/Premiere annee/td3v2exo2.c b/BTS/C/Premiere annee/td3v2exo2.c new file mode 100644 index 0000000..be57f26 --- /dev/null +++ b/BTS/C/Premiere annee/td3v2exo2.c @@ -0,0 +1,13 @@ +#include +#include + +int main() +{ + int coucou; + printf("Dans la forêt lointaine, on entend le coucou.\n"); + printf("Combien de fois entend-on le coucou dans la forêt lointaine ?"); + for(scanf("%d", &coucou); coucou > 0; coucou--){ + printf("Coucou !\n"); + } + printf("Fait le coucou.\n"); +} diff --git a/BTS/C/Premiere annee/td3v2exo3.c b/BTS/C/Premiere annee/td3v2exo3.c new file mode 100644 index 0000000..ae22810 --- /dev/null +++ b/BTS/C/Premiere annee/td3v2exo3.c @@ -0,0 +1,16 @@ +#include +#include + +int main() +{ + unsigned long caseEchec, grain = 1, totGrain = 0; + printf("Lorsque l'inventeur du jeu d'échec présenta son invention au roi des Perses, celui-ci fut émerveillé et informa le créateur qu'il était prêt à satisfaire n'importe quelle demande venant de sa part.\n"); + printf("Après un court instant de réflexion, l'inventeur demande qu'on lui mette 1 grain de blé dans la première case, 2 dans la deuxième, 4 dans la troisième et ainsi de suite en doublant à chaque fois le nombre de grain.\n"); + printf("Bien que surpris par la modestie de la demande, le roi ordonna à son garde grenier de préparer le présent.\n"); + for(caseEchec = 1; caseEchec <= 64; caseEchec++){ + printf("Le garde posa %lu grains dans la %lu case.\n", grain, caseEchec); + totGrain = totGrain + grain; + grain *= 2; + } + printf("Le garde grenier posa au total %lu grains, étant devenu fou, il se suicida.", totGrain); +} diff --git a/BTS/C/Premiere annee/td3v2exo4.c b/BTS/C/Premiere annee/td3v2exo4.c new file mode 100644 index 0000000..8af2ec8 --- /dev/null +++ b/BTS/C/Premiere annee/td3v2exo4.c @@ -0,0 +1,16 @@ +#include +#include + +int main() +{ + double hauteurEiffel = 320.755; //En m + double epaisseurPapier = 0.076474; //En mm + int compteur = 0; + + hauteurEiffel = hauteurEiffel * 1000; //Conversion de mm à m + while(epaisseurPapier < hauteurEiffel){ + epaisseurPapier = epaisseurPapier*2; + compteur++; + } + printf("Le papier atteindra l'épaisseur de la tour Eiffel en %d pliages.", compteur); +} diff --git a/BTS/C/Premiere annee/td3v2exo5.c b/BTS/C/Premiere annee/td3v2exo5.c new file mode 100644 index 0000000..c4f39da --- /dev/null +++ b/BTS/C/Premiere annee/td3v2exo5.c @@ -0,0 +1,18 @@ +#include +#include + +int main() +{ + int annee; + printf("Entrer une année :"); + scanf("%d", &annee); + if(annee%4 != 0){ + printf("L'année entrée n'est pas bissextile.\n"); + }else{ + if(annee%100 == 0 && annee%400 != 0){ + printf("L'année n'est pas bissextile.\n"); + }else{ + printf("L'annéé est bissextile.\n"); + } + } +}; diff --git a/BTS/C/Premiere annee/td3v2exo6.c b/BTS/C/Premiere annee/td3v2exo6.c new file mode 100644 index 0000000..11fa078 --- /dev/null +++ b/BTS/C/Premiere annee/td3v2exo6.c @@ -0,0 +1,31 @@ +#include +#include + +int main() +{ + int combinaison = 164; + int chiffre; + int boucle = 0; + printf("---------\n"); + printf("|Cerrure|\n"); + printf("---------\n"); + + do{ + printf("Entrer une combinaison :"); + scanf("%d", &chiffre); + if(combinaison < 999){ + printf("Valeur saisie incorrecte\n"); + }else{ + if(combinaison == chiffre){ + printf("Code validé.\n"); + boucle += 5; + }else{ + printf("Code incorrect\n"); + } + } + boucle++; + }while(boucle < 3); + if(boucle == 3){ + printf("Le nombre d'erreurs authorisées a été dépassé.\n"); + } +} diff --git a/BTS/C/Premiere annee/td3v2exo7.c b/BTS/C/Premiere annee/td3v2exo7.c new file mode 100644 index 0000000..b0a24f3 --- /dev/null +++ b/BTS/C/Premiere annee/td3v2exo7.c @@ -0,0 +1,18 @@ +#include +#include +#include + +int main() +{ + int limiteA = 1; + int limiteB = 5; + float x = limiteA; + double epsilon = 0.00001; + int boucle; + double integrale = 0; + do{ + integrale += ((x*x + 3*x - 5) * epsilon); + x += epsilon; + }while(x < limiteB); + printf("L'intégrale est égale à %f.", integrale); +} diff --git a/BTS/C/Premiere annee/tdChaines.c b/BTS/C/Premiere annee/tdChaines.c new file mode 100644 index 0000000..69b4ee2 --- /dev/null +++ b/BTS/C/Premiere annee/tdChaines.c @@ -0,0 +1,179 @@ +#include +#include +#define TAILLEMAX 255 + +int main() +{ + void exercice1(char phraseExo[TAILLEMAX]) + { + char bonjour[] = "Bonjour"; + printf("\nVotre phrase est %s", phraseExo); + + //Le strlen permet de calculer la taille d'une chaine de caractères. + printf("\nLa taille de votre phrase est égale à %d.\n", strlen(phraseExo)); + + //Le strcomp permet de comparer entièrement deux chaines de caractères. + if(strcmp(phraseExo, bonjour)) + { + printf("Votre phrase est égale ou commence par \"Bonjour\".\n"); + } + else + { + printf("Votre phrase n'est pas égale à \"Bonjour\".\n"); + } + + //Le strncomp permet de comparer deux chaines de caractères jusqu'à un index ou la fin d'une des chaines de caractère. + if(strncmp(phraseExo, bonjour)) + { + printf("Votre phrase commence par \"Bonjour\".\n"); + } + else + { + printf("Votre phrase ne commence pas par \"Bonjour\".\n"); + } + + //Le strcpy permet de copier une chaine de caractère dans une autre. + strcpy(phraseExo, bonjour); + + printf("La variable phraseExo[] contient maintenant \"%s\".\n", phraseExo); + } + + void exercice2(char phraseExo[TAILLEMAX]) + { + int boucle; + int nbA = 0; + for(boucle = 0; boucle < strlen(phraseExo); boucle++) + { + if(phraseExo[boucle] == 'a') + { + nbA++; + } + } + + printf("Il y a %d lettre a dans la phrase \"%s\".", nbA, phraseExo); + } + + void exercice3(char phraseExo[TAILLEMAX]) + { + int nBvoyelle = 0; + int boucle; + for(boucle = 0; boucle < strlen(phraseExo); boucle++) + { + if(phraseExo[boucle] == 'a' || phraseExo[boucle] == 'e' || phraseExo[boucle] == 'i' || phraseExo[boucle] == 'o' || + phraseExo[boucle] == 'u' || phraseExo[boucle] == 'y') + { + nBvoyelle++; + } + } + printf("Il y a %d voyelle(s).\n", nBvoyelle); + } + + void exercice4(char phraseExo[TAILLEMAX]) + { + int nBconsonne = 0; + int boucle; + for(boucle = 0; boucle < strlen(phraseExo); boucle++) + { + if((phraseExo[boucle] >= 'a' && phraseExo[boucle] <= 'z') || (phraseExo[boucle] >= 'A' && phraseExo[boucle] <= 'Z')) + { + if(phraseExo[boucle] != 'a' && phraseExo[boucle] != 'A' && phraseExo[boucle] != 'e' && phraseExo[boucle] != 'E' && + phraseExo[boucle] != 'i' && phraseExo[boucle] != 'I' && phraseExo[boucle] != 'o' && phraseExo[boucle] != 'O' && + phraseExo[boucle] != 'u' && phraseExo[boucle] != 'U' && phraseExo[boucle] != 'y' && phraseExo[boucle] != 'Y') + { + nBconsonne++; + } + } + } + printf("Il y a %d consonne(s).\n", nBconsonne); + } + + void exercice5(char phraseExo[TAILLEMAX]) + { + int nBmot = 0; + int boucle; + for(boucle = 0; boucle < strlen(phraseExo); boucle++) + { + if((phraseExo[boucle] >= 'a' && phraseExo[boucle] <= 'z') || (phraseExo[boucle] >= 'A' && phraseExo[boucle] <= 'Z')) + { + if((phraseExo[boucle + 1] >= ' ' && phraseExo[boucle+1] <= '/') || + (phraseExo[boucle + 1] >= ':' && phraseExo[boucle+1] <= '@') || + (phraseExo[boucle + 1] >= '[' && phraseExo[boucle+1] <= '`') || phraseExo[boucle+1]=='\0') + { + nBmot++; + } + } + } + printf("Il y a %d mot(s) dans votre phrase.", nBmot); + } + + void exercice6(char phraseExo[TAILLEMAX]) + { + int boucle; + printf("Votre phrase à l'envers donne :\n"); + for(boucle = strlen(phraseExo); boucle >= 0; boucle--){ + printf("%c", phraseExo[boucle]); + } + printf("\n"); + } + + void exercice7(char phraseExo[TAILLEMAX]) + { + char phraseExoInversion[TAILLEMAX]; + int boucle = 0; + for(boucle = 0; boucle < strlen(phraseExo); boucle++) + { + if(phraseExo[boucle] >= 'a' && phraseExo[boucle] <= 'z') + { + phraseExoInversion[boucle] = phraseExo[boucle] - ('a'-'A'); + } + if(phraseExo[boucle] >= 'A' && phraseExo[boucle] <= 'Z') + { + phraseExoInversion[boucle] = phraseExo[boucle] - ('A' - 'a'); + } + } + printf("%s\n", phraseExoInversion); + } + + char phrase[TAILLEMAX]; + int exo; + printf("Saisissez une phrase : "); + gets(phrase); + + printf("Avec quel exercice voulez-vous traiter cette phrase ?\n"); + printf("1- Exemple des différentes fonctions str.\n"); + printf("2- Comptage du nombre de a dans une phrase.\n"); + printf("3- Comptage du nombre de voyelle dans une phrase.\n"); + printf("4- Comptage du nombre de consonne dans une phrase.\n"); + printf("5- Comptage du nombre de mot dans une phrase.\n"); + printf("6- Lire la phrase dans l'ordre inverse.\n"); + printf("7- Inverser majuscule et minuscule.\n"); + printf("Choix :"); + scanf("%d", &exo); + + switch (exo) + { + case 1: + exercice1(phrase); + break; + case 2: + exercice2(phrase); + break; + case 3: + exercice3(phrase); + break; + case 4: + exercice4(phrase); + break; + case 5: + exercice5(phrase); + break; + case 6: + exercice6(phrase); + break; + case 7: + exercice7(phrase); + break; + default: + printf("Il n'y a pas d'exercice pour cette valeur."); + } +} diff --git a/BTS/C/Premiere annee/tdTableau1.c b/BTS/C/Premiere annee/tdTableau1.c new file mode 100644 index 0000000..74e2f7e --- /dev/null +++ b/BTS/C/Premiere annee/tdTableau1.c @@ -0,0 +1,18 @@ +#include +#include + +int main() +{ + int note[24]; + int bouclage; + for(bouclage = 0; bouclage < 24; bouclage++){ + printf("Entrer une note : "); + scanf("%d", ¬e[bouclage]); + } + + printf("\n"); + + for(bouclage = 0; bouclage < 24; bouclage++){ + printf("L'élève %d a eu %d.\n", bouclage+1, note[bouclage]); + } +} diff --git a/BTS/C/Premiere annee/tdTableau2.c b/BTS/C/Premiere annee/tdTableau2.c new file mode 100644 index 0000000..9b0af0b --- /dev/null +++ b/BTS/C/Premiere annee/tdTableau2.c @@ -0,0 +1,39 @@ +#include +#include + +int main() +{ + float tempMin[31]; + float tempMax[31]; + int i; + float testTempMin; + float testTempMax; + int jourTempMin; + int jourTempMax; + + for(i = 0; i <= 30; i++){ + printf("Entrer température minimale : "); + scanf("%f", &tempMin[i]); + printf("Entrer température maximale : "); + scanf("%f", &tempMax[i]); + } + + testTempMax = tempMax[1]; + testTempMin = tempMin[1]; + + for(i = 0; i <= 30; i++){ + if(tempMax[i] > testTempMax){ + jourTempMax = i; + testTempMax = tempMax[i]; + } + if(tempMin[i] < testTempMin){ + jourTempMin = i; + testTempMin = tempMin[i]; + } + } + + printf("La température maximale a été relevée le %d de ce mois-ci et elle était de %.1f.\n", jourTempMax, testTempMax); + printf("La température minimale a été relevée le %d de ce mois-ci et elle était de %.1f.", jourTempMin, testTempMin); + + +} diff --git a/BTS/C/Premiere annee/tdTableau3.c b/BTS/C/Premiere annee/tdTableau3.c new file mode 100644 index 0000000..264addb --- /dev/null +++ b/BTS/C/Premiere annee/tdTableau3.c @@ -0,0 +1,48 @@ +#include +#include +#define TAILLEMAX 255 + +int main() +{ + float tabVal[TAILLEMAX]; + int nbVal = 10; + int i; + float tabValNeg[nbVal]; + float tabValPos[nbVal]; + float sommeTabValNeg = 0; + float miniPos; + float maxiPos; + + for(i = 0; i < nbVal; i++){ + printf("Entrer une valeur : "); + scanf("%f", &tabVal[i]); + + if(tabVal[i] < 0){ + tabValNeg[i] = tabVal[i]; + sommeTabValNeg = sommeTabValNeg + tabVal[i]; + } + + if(tabVal[i] > 0){ + tabValPos[i] = tabVal[i]; + } + } + + miniPos = tabVal[1]; + maxiPos = tabVal[1]; + + for(i = 0; i < nbVal; i++){ + if(miniPos > tabVal[i]){ + miniPos = tabVal[i]; + } + + if(maxiPos < tabVal[i]){ + maxiPos = tabVal[i]; + } + } + + printf("La somme des valeurs négatives est égal à %.0f.\n", sommeTabValNeg); + printf("Il y a %d valeurs nulles dans tabVal.\n", TAILLEMAX - nbVal); + printf("La plus grosse valeur de tabValPos est %.0f.\n", maxiPos); + printf("La plus petite valeur de tabValPos est %.0f.\n", miniPos); + +} diff --git a/BTS/C/Premiere annee/tdTableau4.c b/BTS/C/Premiere annee/tdTableau4.c new file mode 100644 index 0000000..9f54b3a --- /dev/null +++ b/BTS/C/Premiere annee/tdTableau4.c @@ -0,0 +1,41 @@ +#include +#include +#define TAILLE 10 + +int main() +{ + int tabEntier[TAILLE]; + int tabInver[TAILLE]; + int i; + + for(i = 0; i < TAILLE; i++){ + printf("Entrer une valeur: "); + scanf("%d", &tabEntier[i]); + } + + printf("Le tableau est dans l'ordre: {"); + + for(i = 0; i < TAILLE; i++){ + printf("%d, ", tabEntier[i]); + } + + printf("}"); + printf("\n"); + + for(i = 0; i < TAILLE; i++){ + tabInver[9 - i] = tabEntier[i]; + } + + for(i = 0; i < TAILLE; i++){ + tabEntier[i] = tabInver[i]; + } + + printf("Le tableau est dans l'ordre inverse: {"); + + + for(i = 0; i < TAILLE; i++){ + printf("%d, ", tabEntier[i]); + } + + printf("}"); +} diff --git a/BTS/C/Premiere annee/tdTableau5.c b/BTS/C/Premiere annee/tdTableau5.c new file mode 100644 index 0000000..a0ca7c3 --- /dev/null +++ b/BTS/C/Premiere annee/tdTableau5.c @@ -0,0 +1,30 @@ +#include +#include +#define TAILLE 5 + +int main() +{ + int tab[TAILLE] = {5,7,2,1,4}; + int compare = 10000000; + int temp; + int tempBoucle; + int i, j, a, caz; + + for(i = 0; i < TAILLE; i++){ + for(j = 0; j+i < TAILLE; j++){ + if(compare > tab[j+i]){ + compare = tab[j+i]; + caz = j+i; + } + } + temp = tab[i]; + tab[i] = compare; + tab[caz] = temp; + compare = 10000000000; + + } + + for(a = 0; a < TAILLE; a++){ + printf("%d,", tab[a]); + } +} diff --git a/BTS/C/Premiere annee/test.c b/BTS/C/Premiere annee/test.c new file mode 100644 index 0000000..7b83b8c --- /dev/null +++ b/BTS/C/Premiere annee/test.c @@ -0,0 +1,36 @@ +#include +#include + +int main() +{ + float cote; + float chiffre = 1, milieu = 0, compteur = 0; + printf("Saisir un entier impaire :"); + scanf("%f", &cote); + for(int boucleColonne = 1; boucleColonne <= cote/2 + 1; boucleColonne++){ + for(int boucleZero = 1; boucleZero < boucleColonne; boucleZero++){ + printf("0"); + } + for(int boucleLigne = 0; boucleLigne <= cote + 1 - boucleColonne*2; boucleLigne++){ + printf("%.0f", chiffre); + chiffre++; + } + for(int boucleZero = 1; boucleZero < boucleColonne; boucleZero++){ + printf("0"); + } + printf("\n"); + } + for(int boucleColonne = 1; boucleColonne <= cote/2; boucleColonne++){ + for(int boucleZero = ; boucleZero >= boucleColonne; boucleZero--){ + printf("0"); + } + /*for(int boucleLigne = cote/2-1; boucleLigne >= 0; boucleLigne--){ + printf("%.0f", chiffre); + chiffre++; + } + for(int boucleZero = cote/2; boucleZero >= boucleColonne; boucleZero++){ + printf("0"); + } + printf("\n");*/ + } +} diff --git a/BTS/C/Premiere annee/tpManipulationTableau.c b/BTS/C/Premiere annee/tpManipulationTableau.c new file mode 100644 index 0000000..2db778b --- /dev/null +++ b/BTS/C/Premiere annee/tpManipulationTableau.c @@ -0,0 +1,46 @@ +#include +#include +#define NB_RELEVE 5 + +int main() +{ + int testUnsigned; + int boucle; + float moyenne = 0; + unsigned int valMin, valMax; + unsigned int nuagePoints[NB_RELEVE]; + + for(boucle = 0; boucle < NB_RELEVE; boucle++) + { + do{ + printf("Valeur à entrer :"); + scanf("%d", &testUnsigned); + }while(testUnsigned < 0 || testUnsigned > 4096); + nuagePoints[boucle] = testUnsigned; + } + + // Determination du min et du max + valMin = nuagePoints[0]; + valMax = nuagePoints[0]; + for(boucle = 0; boucle < NB_RELEVE; boucle++) + { + if(nuagePoints[boucle] > valMax) + { + valMax = nuagePoints[boucle]; + } + if(nuagePoints[boucle] < valMin) + { + valMin = nuagePoints[boucle]; + } + } + // Calcul de la moyenne + for(boucle = 0; boucle < NB_RELEVE; boucle++) + { + moyenne = moyenne + nuagePoints[boucle]; + } + moyenne = moyenne - (valMax + valMin); + moyenne = moyenne / (NB_RELEVE - 2); + + printf("Moyenne :%.2f\n", moyenne); + return 0; +} diff --git a/BTS/C/Premiere annee/trafficLights/feu.c b/BTS/C/Premiere annee/trafficLights/feu.c new file mode 100644 index 0000000..827020c --- /dev/null +++ b/BTS/C/Premiere annee/trafficLights/feu.c @@ -0,0 +1,91 @@ +#include "fonctions.h" + +int changerEtat(feu *pfeu) +{ + + switch(pfeu->etatActuel) + { + + case RECOUVREMENT: + + if (pfeu->debut==1) + { + pfeu->etatActuel = VERT; + pfeu->finCycle = 0; + } + + printf("%s rouge %d allume\n", pfeu->id, pfeu->pinRouge); + digitalWrite(pfeu->pinRouge,1); + digitalWrite(pfeu->pinOrange,0); + digitalWrite(pfeu->pinVert,0); + break; + + case VERT: + + if (pfeu->timer[VERT]>15) + { + pfeu->etatActuel = ORANGE; + pfeu->timer[VERT]=0; + } + + pfeu->timer[VERT]++; + digitalWrite(pfeu->pinRouge,0); + digitalWrite(pfeu->pinOrange,0); + digitalWrite(pfeu->pinVert,1); + printf("%s vert %d allume\n", pfeu->id, pfeu->pinVert); + break; + + case ORANGE: + + if (pfeu->timer[ORANGE]>=3) + { + pfeu->etatActuel = ROUGE; + pfeu->timer[ORANGE] = 0; + } + + pfeu->timer[ORANGE]++; + printf("%s orange %d allume\n", pfeu->id, pfeu->pinOrange); + digitalWrite(pfeu->pinRouge,0); + digitalWrite(pfeu->pinOrange,1); + digitalWrite(pfeu->pinVert,0); + break; + + case ROUGE: + + if (pfeu->timer[ROUGE]>2) + { + pfeu->etatActuel = RECOUVREMENT; + + pfeu->finCycle = 1; + pfeu->timer[ROUGE] = 0; + } + + pfeu->timer[ROUGE]++; + printf("%s rouge %d allume\n", pfeu->id, pfeu->pinRouge); + digitalWrite(pfeu->pinRouge,1); + digitalWrite(pfeu->pinOrange,0); + digitalWrite(pfeu->pinVert,0); + break; + } + return 0; +} + +int initialisation(feu *pfeu) +{ + pfeu->etatActuel = RECOUVREMENT; + pfeu->finCycle = 0; + pfeu->timer[ROUGE] = 0; + pfeu->timer[ORANGE] = 0; + pfeu->timer[VERT]= 0; + return 0; +} + +void initialisationGPIO() +{ + int i; + wiringPiSetup(); + for(i=0; i<8; i++) + { + //pinMode(i,OUTPUT); + } +} diff --git a/BTS/C/Premiere annee/trafficLights/feu.h b/BTS/C/Premiere annee/trafficLights/feu.h new file mode 100644 index 0000000..be6a4ad --- /dev/null +++ b/BTS/C/Premiere annee/trafficLights/feu.h @@ -0,0 +1,26 @@ +#include +#include +#include +#include +//#include + +#ifndef FONCTIONS_H_INCLUDED +#define FONCTIONS_H_INCLUDED + +#define NBCARMAX 50 + +enum etat {RECOUVREMENT,VERT,ORANGE,ROUGE}; + +typedef struct { + + enum etat etatActuel; + char id[NBCARMAX]; + char debut; + char finCycle; + int timer[4]; + char pinRouge; + char pinOrange; + char pinVert; +}feu; + +#endif // FONCTIONS_H_INCLUDED diff --git a/BTS/C/Premiere annee/trafficLights/fonctions.c b/BTS/C/Premiere annee/trafficLights/fonctions.c new file mode 100644 index 0000000..9bd84c6 --- /dev/null +++ b/BTS/C/Premiere annee/trafficLights/fonctions.c @@ -0,0 +1,75 @@ +#include "fonctions.h" + +void effacerEcran(){ + printf("%c[2J", 0x1B); + printf("\033[50A"); +} + +int changerEtat(feu *pfeu) +{ + + switch(pfeu->etatActuel) + { + + case RECOUVREMENT: + + if (pfeu->debut==1) + { + pfeu->etatActuel = VERT; + pfeu->finCycle = 0; + } + + printf("%s%s%s ████\n", RESET, pfeu->id, RED); + break; + + case VERT: + + if (pfeu->timer[VERT]>15) + { + pfeu->etatActuel = ORANGE; + pfeu->timer[VERT]=0; + } + + pfeu->timer[VERT]++; + printf("%s%s%s ████\n", RESET, pfeu->id, GREEN); + break; + + case ORANGE: + + if (pfeu->timer[ORANGE]>=3) + { + pfeu->etatActuel = ROUGE; + pfeu->timer[ORANGE] = 0; + } + + pfeu->timer[ORANGE]++; + printf("%s%s%s ████\n", RESET, pfeu->id, YELLOW); + break; + + case ROUGE: + + if (pfeu->timer[ROUGE]>2) + { + pfeu->etatActuel = RECOUVREMENT; + + pfeu->finCycle = 1; + pfeu->timer[ROUGE] = 0; + } + + pfeu->timer[ROUGE]++; + printf("%s%s%s ████\n", RESET, pfeu->id, RED); + break; + } + return 0; +} + +int initialisation(feu *pfeu) +{ + pfeu->etatActuel = RECOUVREMENT; + pfeu->finCycle = 0; + pfeu->timer[ROUGE] = 0; + pfeu->timer[ORANGE] = 0; + pfeu->timer[VERT]= 0; + return 0; +} + diff --git a/BTS/C/Premiere annee/trafficLights/fonctions.h b/BTS/C/Premiere annee/trafficLights/fonctions.h new file mode 100644 index 0000000..3a1c868 --- /dev/null +++ b/BTS/C/Premiere annee/trafficLights/fonctions.h @@ -0,0 +1,36 @@ +#include +#include +#include +#include + +#ifndef FONCTIONS_H_INCLUDED +#define FONCTIONS_H_INCLUDED + +#define NBCARMAX 50 + +#define RESET "\033[1;0m" +#define RED "\033[1;31m" +#define YELLOW "\033[1;33m" +#define GREEN "\033[1;32m" + +enum etat {RECOUVREMENT,VERT,ORANGE,ROUGE}; + +typedef struct { + + enum etat etatActuel; + char id[NBCARMAX]; + char debut; + char finCycle; + int timer[4]; + char pinRouge; + char pinOrange; + char pinVert; +}feu; + +int changerEtat(feu *pfeu); + +int initialisation(feu *pfeu); + +void effacerEcran(); + +#endif // FONCTIONS_H_INCLUDED diff --git a/BTS/C/Premiere annee/trafficLights/main.c b/BTS/C/Premiere annee/trafficLights/main.c new file mode 100644 index 0000000..e933d73 --- /dev/null +++ b/BTS/C/Premiere annee/trafficLights/main.c @@ -0,0 +1,36 @@ +#include "fonctions.h" + +int main() +{ + feu feu1; + feu feu2; + + initialisation(&feu1); + initialisation(&feu2); + + strcpy(feu1.id,"Voie A"); + strcpy(feu2.id,"Voie B"); + + feu1.pinRouge = 1; + feu1.pinOrange = 2; + feu1.pinVert = 3; + feu2.pinRouge = 4; + feu2.pinOrange = 5; + feu2.pinVert = 6; + + + feu2.finCycle = 1; + + + while(1) + { + effacerEcran(); + feu1.debut = feu2.finCycle; + changerEtat(&feu1); + feu2.debut = feu1.finCycle; + changerEtat(&feu2); + + sleep(1); + } + return 0; +} diff --git a/BTS/C/Premiere annee/trafficLights/mainFeu.c b/BTS/C/Premiere annee/trafficLights/mainFeu.c new file mode 100644 index 0000000..e933d73 --- /dev/null +++ b/BTS/C/Premiere annee/trafficLights/mainFeu.c @@ -0,0 +1,36 @@ +#include "fonctions.h" + +int main() +{ + feu feu1; + feu feu2; + + initialisation(&feu1); + initialisation(&feu2); + + strcpy(feu1.id,"Voie A"); + strcpy(feu2.id,"Voie B"); + + feu1.pinRouge = 1; + feu1.pinOrange = 2; + feu1.pinVert = 3; + feu2.pinRouge = 4; + feu2.pinOrange = 5; + feu2.pinVert = 6; + + + feu2.finCycle = 1; + + + while(1) + { + effacerEcran(); + feu1.debut = feu2.finCycle; + changerEtat(&feu1); + feu2.debut = feu1.finCycle; + changerEtat(&feu2); + + sleep(1); + } + return 0; +} diff --git a/BTS/C/Premiere annee/utilisationFseek.c b/BTS/C/Premiere annee/utilisationFseek.c new file mode 100644 index 0000000..0244234 --- /dev/null +++ b/BTS/C/Premiere annee/utilisationFseek.c @@ -0,0 +1,32 @@ +#include +#include +#include +#define TAILLEMAX 50 + +int main() +{ + int largeur,hauteur,nbCouleur; + + FILE *pPicture = fopen("/home/USERS/ELEVES/SNIR2015/imgBMP/image256Couleurs.bmp", "r"); + + if(errno != NULL){ + printf("Erreur fichier : erreur n'%d\n", errno); + exit(0); + } + + fseek(pPicture, 18, SEEK_SET); + + fread(&largeur, sizeof(int), 1, pPicture); + + fread(&hauteur, sizeof(int), 1, pPicture); + + fseek(pPicture, 28, SEEK_CUR); + + fread(&nbCouleur, sizeof(int), 1, pPicture); + + printf("%d\n",largeur); + printf("%d\n",hauteur); + printf("%d",nbCouleur); + + return 0; +}