moitié tp 3

prepa_CM3/ex1_A.c

@@ -0,0 +1,59 @@
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+struct mail {
+  int valeur;
+  struct mail* suivant;
+};
+typedef struct mail maillon;
+
+
+int test(maillon* premier,int new){
+  if(premier==NULL){
+    return 1;
+  }
+  
+	   if (new % premier->valeur==0)
+       return 0;
+test(premier->suivant,new);
+}
+
+
+maillon* ajouter_debut(maillon* premier, int nouveau) {
+  maillon* p = (maillon*) malloc(sizeof(maillon));
+  if (p) {
+    p->suivant = premier;
+    p->valeur = nouveau;
+  }
+  return p;
+}
+
+
+
+
+int main() {
+    int currentNumber, stop=1;
+    maillon* debut=NULL;
+
+    while (stop) {
+        printf("Entrez un entier : ");
+        scanf("%d", &currentNumber);
+
+        if (currentNumber <= 0) {
+            printf("Fin du programme.\n");
+            stop=0;
+        }
+
+
+        if (test(debut,currentNumber)==0) {
+            printf("Perdu !\n");
+            stop=0;
+        }
+		debut=ajouter_debut(debut,currentNumber);
+        
+    }
+
+    return 0;
+}

prepa_CM3/ex1_B.c

@@ -0,0 +1,75 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+/* Définition de la structure pour un maillon de la liste chaînée*/
+struct Node {
+    int value;
+    struct Node* next;
+};
+
+/* Alias pour faciliter l'utilisation de la structure*/
+typedef struct Node Node;
+
+/* Fonction pour ajouter un entier dans la liste de manière ordonnée*/
+Node* insertOrdered(Node* head, int value) {
+    Node* newNode = (Node*)malloc(sizeof(Node));
+    Node* current;
+    newNode->value = value;
+    newNode->next = NULL;
+
+    if (head == NULL || value < head->value) {
+        newNode->next = head;
+        return newNode;
+    }
+
+    current = head;
+    while (current->next != NULL && current->next->value < value) {
+        current = current->next;
+    }
+
+    newNode->next = current->next;
+    current->next = newNode;
+
+    return head;
+}
+
+/* Fonction pour afficher les valeurs dans la liste*/
+void displayList(Node* head) {
+    Node* current = head;
+
+    while (current != NULL) {
+        printf("%d ", current->value);
+        current = current->next;
+    }
+
+    printf("\n");
+}
+
+int main() {
+    Node* head = NULL;  /* Tête de la liste*/
+
+    while (1) {
+        int userInput;
+
+        printf("Entrez un entier (ou appuyez sur Entrée pour quitter) : ");
+        if (scanf("%d", &userInput) != 1) {
+            /* L'utilisateur a appuyé sur Entrée, quitter la boucle*/
+            break;
+        }
+
+        /* Insérer l'entier dans la liste de manière ordonnée*/
+        head = insertOrdered(head, userInput);
+
+        /* Afficher la liste actuelle*/
+        displayList(head);
+    }
+
+    /* Libérer la mémoire allouée pour la liste à la fin du programme*/
+    while (head != NULL) {
+        Node* temp = head;
+        head = head->next;
+        free(temp);
+    }
+
+    return 0;
+}

prepa_CM3/ex2_A.c

@@ -0,0 +1,26 @@
+#include <stdio.h>
+
+int rechercheRecursive(int valeur, int tableau[], int taille, int indice) {
+    if (indice == taille) {
+        return -1;
+    }
+    if (tableau[indice] == valeur) {
+        return indice;
+    }
+    return rechercheRecursive(valeur, tableau, taille, indice + 1);
+}
+
+int main() {
+    int tableau[] = {5, 10, 15, 20, 25, 30, 10, 40, 50};
+    int taille = sizeof(tableau) / sizeof(tableau[0]);
+    int resultat = rechercheRecursive(12, tableau, taille, 0);
+    printf("Test 1 - Valeur non présente : %d\n", resultat);
+    resultat = rechercheRecursive(5, tableau, taille, 0);
+    printf("Test 2 - Valeur présente au début : %d\n", resultat);
+    resultat = rechercheRecursive(50, tableau, taille, 0);
+    printf("Test 3 - Valeur présente à la fin : %d\n", resultat);
+    resultat = rechercheRecursive(10, tableau, taille, 0);
+    printf("Test 4 - Valeur présente duex fois : %d\n", resultat);
+
+    return 0;
+}

prepa_CM3/ex2_B.c

@@ -0,0 +1,31 @@
+#include <stdio.h>
+
+double recursiveSum(const double array[], int size) {
+    /* Cas de base : tableau de taille 1*/
+    if (size == 1) {
+        return array[0];
+    }
+
+    /* Appel récursif : somme du premier élément et du reste du tableau*/
+    return array[0] + recursiveSum(array + 1, size - 1);
+}
+
+int main() {
+    /* Test 1 : tableau de 5 éléments*/
+    double array1[] = {1.5, 2.5, 3.5, 4.5, 5.5};
+    double array2[1] = {10.0};
+    double array3[4] = {2.0, 4.0, 6.0, 8.0};
+    int size1 = sizeof(array1) / sizeof(array1[0]);
+    int size2, size3;
+    printf("Somme du tableau 1 : %.2f\n", recursiveSum(array1, size1));
+
+    /* Test 2 : tableau de 1 élément*/
+    size2 = sizeof(array2) / sizeof(array2[0]);
+    printf("Somme du tableau 2 : %.2f\n", recursiveSum(array2, size2));
+
+    /* Test 3 : tableau de 4 éléments, mais considéré de taille 3*/
+    size3 = 3;
+    printf("Somme du tableau 3 : %.2f\n", recursiveSum(array3, size3));
+
+    return 0;
+}

prepa_CM3/ex3_A/makefile

@@ -0,0 +1,19 @@
+but : ex3
+
+OBJS = stack_operations.o\
+		stack.o
+
+CC = gcc
+
+CFLAGS = -Wall -ansi -pedantic
+
+
+stack_operations.o: stack.h
+
+stack.o : stack.h
+
+ex3: $(OBJS)
+	$(CC) $(CFLAGS) -o ex3 $(OBJS)
+
+clean:
+	rm -f $(OBJS) ex3

prepa_CM3/ex3_A/stack.c

@@ -0,0 +1,60 @@
+#include <stdlib.h>
+#include "stack.h"
+
+struct s_link {
+  unsigned value;
+  struct s_link *next;
+};
+
+typedef struct s_link link;
+
+struct s_stack {
+  link *first;
+};
+
+
+/* crée une pile vide */
+stack create_stack(void) {
+  return (stack) calloc(1, sizeof(struct s_stack));
+}
+
+/* ajoute un élément à la pile. Renvoie 1 en cas de succès */
+int push(stack the_stack, unsigned the_value) {
+  link *new = (link*) malloc(sizeof(link));
+  if (new == NULL) {
+    return 0;
+  }
+  new->value = the_value;
+  new->next = the_stack->first;
+  the_stack->first = new;
+  return 1;
+}
+
+/* renvoie 1 si la pile est vide */
+int empty(stack the_stack) {
+  return the_stack->first == NULL;
+}
+
+/* retire un élément de la pile. Renvoie l'élément retiré, ou -1 en cas d'échec */
+long pop(stack the_stack) {
+  if(the_stack->first == NULL) {
+    return -1;
+  }
+  link l = *(the_stack->first);
+  free(the_stack->first);
+  the_stack->first = l.next;
+  return l.value;
+}
+
+/* détruit une pile en libérant les ressources associées */
+void destroy_stack(stack the_stack) {
+  link *current, *saved;
+
+  current = the_stack->first;
+  while(current != NULL) {
+    saved = current->next;
+    free(current);
+    current = saved;
+  }
+  free(the_stack);
+}

prepa_CM3/ex3_A/stack.h

@@ -0,0 +1,22 @@
+#ifndef STACK_H
+#define STACK_H
+
+/* le type stack représente une pile */
+typedef struct s_stack *stack;
+
+/* crée une pile vide. Renvoie NULL en cas d'échec */
+stack create_stack(void);
+
+/* ajoute un élément à la pile. Renvoie 0 en cas d'échec */
+int push(stack, unsigned);
+
+/* renvoie 1 si la pile est vide */
+int empty(stack);
+
+/* retire un élément de la pile. Renvoie l'élément retiré, ou -1 en cas d'échec */
+long pop(stack);
+
+/* détruit une pile en libérant les ressources associées */
+void destroy_stack(stack);
+
+#endif /* STACK_H */

prepa_CM3/ex3_A/stack_operations.c

@@ -0,0 +1,63 @@
+#include <stdio.h>
+#include "stack.h"
+
+/* Retire de la pile tous les éléments valant 0 */
+void removeZeros(stack s) {
+    stack tempStack = create_stack();
+
+    /* Transférer les éléments non nuls vers une pile temporaire*/
+    while (!empty(s)) {
+        long value = pop(s);
+        if (value != 0) {
+            push(tempStack, value);
+        }
+    }
+
+    /* Transférer les éléments depuis la pile temporaire vers la pile d'origine*/
+    while (!empty(tempStack)) {
+        push(s, pop(tempStack));
+    }
+
+    /* Libérer la mémoire de la pile temporaire*/
+    destroy_stack(tempStack);
+}
+
+int main() {
+    stack myStack = create_stack();
+
+    /* Ajouter des éléments à la pile (exemple)*/
+    push(myStack, 0);
+    push(myStack, 5);
+    push(myStack, 0);
+    push(myStack, 8);
+    push(myStack, 0);
+    push(myStack, 3);
+
+    /* Afficher la pile avant la suppression des zéros*/
+    printf("Pile avant suppression des zéros : ");
+    while (!empty(myStack)) {
+        printf("%ld ", pop(myStack));
+    }
+    printf("\n");
+
+    /* Remettre des éléments à la pile (exemple)*/
+    push(myStack, 0);
+    push(myStack, 9);
+    push(myStack, 0);
+    push(myStack, 7);
+
+    /* Appliquer la fonction pour retirer les zéros*/
+    removeZeros(myStack);
+
+    /* Afficher la pile après la suppression des zéros*/
+    printf("Pile après suppression des zéros : ");
+    while (!empty(myStack)) {
+        printf("%ld ", pop(myStack));
+    }
+    printf("\n");
+
+    /* Libérer la mémoire de la pile*/
+    destroy_stack(myStack);
+
+    return 0;
+}

prepa_CM3/ex3_B/makefile

@@ -0,0 +1,15 @@
+but: ex3
+OBJS = queu.o\
+		text.o
+CC = gcc
+CFLAGS = -Wall -ansi -pedantic
+
+queu.o: queue.h
+
+text.o: queue.h
+
+ex3: $(OBJS)
+	$(CC) $(CFLAGS) -o ex3 $(OBJS)
+
+clean:
+	rm -f $(OBJS) ex3

prepa_CM3/ex3_B/queu.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 1 en cas de succès */
+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);
+}

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

prepa_CM3/ex3_B/text.c

@@ -0,0 +1,51 @@
+#include <stdio.h>
+#include "queue.h"
+
+/* Affiche les éléments de la file du plus ancien au plus récent */
+void displayQueue(queue q) {
+    queue tempQueue = create_queue(); /* File temporaire pour stocker les éléments*/
+    int value;
+
+    /* Afficher les éléments de la file et les stocker temporairement*/
+    while (!empty(q)) {
+        value = dequeue(q);
+        printf("%d ", value);
+        enqueue(tempQueue, value);
+    }
+
+    /* Remettre les éléments dans la file d'origine*/
+    while (!empty(tempQueue)) {
+        enqueue(q, dequeue(tempQueue));
+    }
+
+    /* Libérer la file temporaire*/
+    destroy_queue(tempQueue);
+
+    printf("\n");
+}
+
+int main() {
+    /* Créer une file et ajouter des éléments (exemple)*/
+    queue myQueue = create_queue();
+    enqueue(myQueue, 14);
+    enqueue(myQueue, 9);
+    enqueue(myQueue, 28);
+    enqueue(myQueue, -3);
+
+    /* Afficher les éléments de la file sans altérer la file*/
+    printf("File avant affichage : ");
+    displayQueue(myQueue);
+
+    /* Ajouter quelques éléments supplémentaires (exemple)*/
+    enqueue(myQueue, 5);
+    enqueue(myQueue, 12);
+
+    /* Afficher les éléments de la file après ajout*/
+    printf("File après ajout : ");
+    displayQueue(myQueue);
+
+    /* Libérer la mémoire de la file*/
+    destroy_queue(myQueue);
+
+    return 0;
+}