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 */