Java

DEV1.1/CM3/Makefile

@@ -0,0 +1,24 @@
+CC = gcc
+CFLAGS = -ansi \
+         -pedantic
+EXE = final
+OFILES = queue.o \
+         bifurcation.o
+ 
+### BUT PAR DEFAUT ###
+ 
+final : ${EXE}
+ 
+### REGLES ESSENTIELLES ###
+ 
+bifuraction.o : bifurcation.c
+ 
+queue.o : queue.h queue.c
+ 
+${EXE} : ${OFILES}
+	$(CC) $(CFLAGS) -o ${EXE} ${OFILES}
+
+### REGLES OPTIONNELLES ###
+
+clean :
+	-rm -f ${OFILES} ${EXE}

DEV1.1/CM3/bifurcation.c

@@ -0,0 +1,37 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "queue.h"
+
+
+int main(int argc, char** argv) {
+	queue file = create_queue();
+	int somme = 0;
+	int i;
+	if (argc < 2) {
+		printf("Rien n'a été écrit en ligne de commande.\n");
+		return EXIT_FAILURE;
+	}
+
+	for (i = 0; i != argc; i++) {
+		int valeur = atoi(argv[i]);
+		if (valeur == 0) {
+			/* Rien */
+		}
+		else {
+			somme += valeur;
+			/* Etant donné que la file doit stocker des long et ne peut pas stocker des char*,
+			je stocke les BONNES valeurs dans la liste pour afficher plus tard celles qui n'en font pas partie */
+			enqueue(file, strtol(argv[i], NULL, 10));
+		}
+	}
+
+	printf("somme : %d\n", somme);
+	printf("ignorés : ");
+	while (!empty(file)) {
+		printf("%c", (char) dequeue(file));
+		putchar(' ');
+	}
+	destroy_queue(file);
+	return EXIT_SUCCESS;
+}

DEV1.1/CM3/bilan.c

@@ -0,0 +1,26 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+         
+int nb_negatifs(int* tab, size_t taille_tab) {
+	if (taille_tab == 0) {
+		return 0;
+	}
+	return (tab[taille_tab-1] < 0) + nb_negatifs(tab, taille_tab-1);
+}
+
+
+int main(void) {
+	int tab_1[5]; /* Vide */
+	int tab_2[5] = {2, 4, 1, 38, 0}; /* Positif ou nul */
+	int tab_3[5] = {-2, -7, -20, -829, -1000}; /* Strictement négatif */
+	int tab_4[5] = {3, -7, 11, 0, -50}; /* Signe divers et au moins une valeur nulle */
+
+	printf("%d\n", nb_negatifs(tab_1, 5));
+	printf("%d\n", nb_negatifs(tab_2, 5));
+	printf("%d\n", nb_negatifs(tab_3, 5));
+	printf("%d\n", nb_negatifs(tab_4, 5));
+
+	for
+	return EXIT_SUCCESS;
+}

DEV1.1/CM3/blague.c

@@ -0,0 +1,13 @@
+#include<stdlib.h>
+#include<stdio.h>
+#include<time.h>
+
+int main(void) {
+  srand(time(NULL));
+  if (rand()%2) {
+    printf("Ϳоie !\n");
+  } else {
+    printf("Désespoir !\n");
+  }
+  return EXIT_SUCCESS;
+}

DEV1.1/CM3/blague_resolu.c

@@ -0,0 +1,77 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct {
+	char valeurs[1000];
+	int debut;
+	int fin;
+	size_t taille;
+} file;
+
+void initialise_file(file* f) {
+	f->debut = 0;
+	f->fin = 0;
+	f->taille = 0;
+}
+
+int empty(file* f) {
+	return (f->taille == 0);
+}
+
+void enqueue(file* f, char c) {
+	f->valeurs[f->fin] = c; 
+	f->fin++;
+	f->taille++;
+}
+
+char dequeue(file* f) {
+	if (empty(f)) {
+		printf("Erreur : La file est vide.\n");
+		return;
+	}
+	f->debut++;
+	f->taille--;
+	return f->valeurs[f->debut-1];
+}
+
+int main(int argc, char** argv) {
+	FILE* fichier = NULL;
+	file f;
+	char resultat;
+	initialise_file(&f);
+	if (argc != 2) {
+		printf("Il faut entrer un (unique) chemin de fichier.\n");
+		return EXIT_FAILURE;
+	}
+	fichier = fopen(argv[1], "r");
+	if (fichier == NULL) {
+		printf("Erreur d'ouverture.\n");
+		return EXIT_FAILURE;
+	}
+	fread(&resultat, 1, 1, fichier);
+	if (resultat == ';') { /* Point d'interrogation grec */ 
+		enqueue(&f, ';'); /* Point virgule */
+	}
+	else {
+		enqueue(&f, resultat);
+	}
+	while (feof(fichier) != 0) {
+		fread(&resultat, 1, 1, fichier);
+		if (resultat == ';') { /* Point d'interrogation grec */ 
+			enqueue(&f, ';'); /* Point virgule */
+		}
+		else {
+			enqueue(&f, resultat);
+	}
+	fclose(fichier);
+
+	fichier = fopen(fichier, "w+");
+	while (feof(fichier) != 0) {
+		resultat = dequeue(&f);
+		fwrite(&resultat, 1, 1, fichier);
+	}
+	fclose(fichier);
+
+
+	return EXIT_SUCCESS;
+}

DEV1.1/CM3/queue.c

@@ -0,0 +1,69 @@
+#include <stdlib.h>
+#include "queue.h"
+
+struct s_link {
+  unsigned value;
+  struct s_link *next;
+};
+
+typedef struct s_link link;
+
+struct s_queue {
+  link *first; /* sortie */
+  link *last;  /* entrée */
+};
+
+
+/* crée une file vide */
+queue create_queue(void) {
+  return (queue) calloc(1, sizeof(struct s_queue));
+}
+
+/* ajoute un élément à la file. Renvoie 0 en cas d'échec */
+int enqueue(queue the_queue, unsigned the_value) {
+  link *new = (link*) malloc(sizeof(link));
+  if (new == NULL) {
+    return 0;
+  }
+  new->value = the_value;
+  new->next = NULL;
+  if (the_queue->last == NULL) {
+    the_queue->first = new;
+  } else {
+    the_queue->last->next = new;
+  }
+  the_queue->last = new;
+  return 1;
+}
+
+/* renvoie 1 si la file est vide */
+int empty(queue the_queue) {
+  return the_queue->first == NULL;
+}
+
+/* retire un élément de la file. Renvoie l'élément retiré, ou -1 en cas d'échec */
+long dequeue(queue the_queue) {
+  if(the_queue->first == NULL) {
+    return -1;
+  }
+  link l = *(the_queue->first);
+  free(the_queue->first);
+  the_queue->first = l.next;
+  if (the_queue->first == NULL) {
+    the_queue->last = NULL;
+  }
+  return l.value;
+}
+
+/* détruit une file en libérant les ressources associées */
+void destroy_queue(queue the_queue) {
+  link *current, *saved;
+
+  current = the_queue->first;
+  while(current != NULL) {
+    saved = current->next;
+    free(current);
+    current = saved;
+  }
+  free(the_queue);
+}

DEV1.1/CM3/queue.h

@@ -0,0 +1,22 @@
+#ifndef QUEUE_H
+#define QUEUE_H
+
+/* le type queue représente une file */
+typedef struct s_queue *queue;
+
+/* crée une file vide. Renvoie NULL en cas d'échec */
+queue create_queue(void);
+
+/* ajoute un élément à la file. Renvoie 0 en cas d'échec */
+int enqueue(queue, unsigned);
+
+/* renvoie 1 si la file est vide */
+int empty(queue);
+
+/* retire un élément de la file. Renvoie l'élément retiré, ou -1 en cas d'échec */
+long dequeue(queue);
+
+/* détruit une file en libérant les ressources associées */
+void destroy_queue(queue);
+
+#endif /* QUEUE_H */

DEV1.1/TP31/TP31_reponses.txt

@@ -0,0 +1,97 @@
+----- TP31 : Concepts en vrac -----
+
+1. 
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct {
+	unsigned int durabilite : 10;
+	unsigned int deplacement : 4;
+	unsigned int defense : 7;
+	unsigned int degats : 7;
+	unsigned int distance : 4;
+} unite;
+
+int main(void) {
+	unite test;
+	test.durabilite = 7;
+	test.defense = 7;
+	test.degats = 7;
+	test.deplacement = 7;
+	test.distance = 7;
+	return EXIT_SUCCESS;
+}
+
+2.
+
+#include <stdio.h>
+#include <stdlib.h>
+
+enum wedge {
+	PITCHING = 1,
+	GAP = 2,
+	SAND = 3,
+	LOP = 4,
+	FLIP = 5
+};
+
+enum putter {
+	REGULAR = 1,
+	BELLY = 2,
+	LONG = 3
+};
+
+
+typedef struct {
+	char* marque;
+	char* modele;
+	char* categorie;
+	unsigned int sous_categorie : 4;
+} club;
+
+void affiche_catalogue(int taille_catalogue, club* catalogue) {
+	int i;
+	char* wedge[5] = {"Pitching", "Gap", "Sand", "Lop", "Flip"};
+	char* putter[3] = {"Regular", "Belly", "Long"};
+	printf("| Marque | Modèle | Catégorie | Sous-catégorie |\n");
+	printf("------------------------------------------------\n");
+	for (i = 0; i != taille_catalogue; i++) {
+		if (filtre(catalogue[i])) {
+			printf("| %6s | %6s | %9s | %14d |\n", catalogue[i].marque, catalogue[i].modele, catalogue[i].categorie, catalogue[i].sous_categorie);
+		}
+	}
+}
+
+int filtre(club article) {
+	return article.categorie == "Fer" && article.sous_categorie <= 4;
+}
+
+int main(void) {
+	int i;
+	club catalogue[100];
+	char* marques[4] = {"A", "B", "C", "D"};
+	char* modeles[4] = {"M", "N", "O", "P"};
+	char* categories[4] = {"Bois", "Fer", "Wedge", "Putter"};
+	srand(time(NULL));
+	for(i = 0; i != 100; i++) {
+		catalogue[i].marque = marques[rand() % 4];
+		catalogue[i].modele = modeles[rand() % 4];
+		catalogue[i].categorie = categories[rand() % 4];
+		if (catalogue[i].categorie == "Wedge") {
+			catalogue[i].sous_categorie = rand() % 5;
+		}
+		else if (catalogue[i].categorie == "Putter") {
+			catalogue[i].sous_categorie = rand() % 3;
+		}
+		else {
+			catalogue[i].sous_categorie = rand() % 9 + 1;
+		}
+	}
+	affiche_catalogue(100, catalogue);
+
+	return EXIT_SUCCESS;
+}
+
+3.
+

DEV1.1/TP31/test.c

@@ -1,61 +1,29 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-enum wedge {
-	PITCHING = 1,
-	GAP = 2,
-	SAND = 3,
-	LOP = 4,
-	FLIP = 5
-};
 
-enum putter {
-	REGULAR = 1,
-	BELLY = 2,
-	LONG = 3
-};
+void afficherTableau(unsigned short tab[], size_t taille) {
+    if (taille == 0) {
+        return;
+    }
 
+    if (taille == sizeof(tab) / sizeof(tab[0])) {
+        printf("{");
+    }
 
-typedef struct {
-	char* marque;
-	char* modele;
-	char* categorie;
-	unsigned int sous_categorie : 4;
-} club;
+    printf("%d", tab[0]);
 
-void affiche_catalogue(int taille_catalogue, club* catalogue) {
-	int i;
-	char* wedge[5] = {"Pitching", "Gap", "Sand", "Lop", "Flip"};
-	char* putter[3] = {"Regular", "Belly", "Long"};
-	printf("| Marque | Modèle | Catégorie | Sous-catégorie |\n");
-	printf("------------------------------------------------\n");
-	for (i = 0; i != taille_catalogue; i++) {
-		printf("| %6s | %6s | %9s | %14d |\n", catalogue[i].marque, catalogue[i].modele, catalogue[i].categorie, catalogue[i].sous_categorie);
-	}
+    if (taille > 1) {
+        printf(", ");
+        afficherTableau(tab + 1, taille - 1);
+    } else {
+        printf("}");
+    }
 }
 
-int main(void) {
-	int i;
-	club catalogue[10];
-	char* marques[4] = {"A", "B", "C", "D"};
-	char* modeles[4] = {"M", "N", "O", "P"};
-	char* categories[4] = {"Bois", "Fer", "Wedge", "Putter"};
-	srand(time(NULL));
-	for(i = 0; i != 10; i++) {
-		catalogue[i].marque = marques[rand() % 4];
-		catalogue[i].modele = modeles[rand() % 4];
-		catalogue[i].categorie = categories[rand() % 4];
-		if (catalogue[i].categorie == "Wedge") {
-			catalogue[i].sous_categorie = rand() % 5;
-		}
-		else if (catalogue[i].categorie == "Putter") {
-			catalogue[i].sous_categorie = rand() % 3;
-		}
-		else {
-			catalogue[i].sous_categorie = rand() % 9 + 1;
-		}
-	}
-	affiche_catalogue(10, catalogue);
 
+int main(void) {
+	unsigned short int tab[4] = {1,2,3,4};
+	afficherTableau(tab, 4);
 	return EXIT_SUCCESS;
 }