moitié tp 3

DEV1.1/CM3/calcul.c

@@ -0,0 +1,37 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct mail {
+  long int valeur;
+  struct mail* suivant;
+};
+typedef struct mail maillon;
+
+void ajouter_fin(maillon* debut, double nouv){
+	maillon* p = (maillon*) malloc(sizeof(maillon*));
+	p->valeur = nouv;
+	maillon* fin;
+	fin = debut;
+	while(fin->suivant != NULL)
+		fin = fin->suivant;
+	fin->suivant = p;
+	p->suivant = NULL;
+	
+int affichage(maillon* debut){
+	if (debut->suivant == NULL){
+		printf("%f",debut->valeur);
+		return EXIT_SUCCESS;
+	}else
+		affichage(debut->suivant);
+	printf("%f",debut->valeur);
+	return EXIT_SUCCESS;
+		
+int main(int argc, char** argv){
+	long int val1, val2;
+	int i;
+	maillon* debut1 = NULL;
+	maillon* debut2 = NULL;
+	val1 = strtol(argv[1],NULL,10);
+	val2 = strtol(argv[2],NULL,10);
+		

DEV1.1/CM3/culmination1.c

@@ -0,0 +1,27 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/*la variable grand lors du début du programme est la première valeur du tableau
+et le tableau ne contient pas son premier élément*/
+long int superieur(long int tab[], int taille, long int grand){
+	if (taille < 1)
+		return grand;
+	else if (tab[0] > grand)
+		grand = tab[0];
+	printf("n\n");
+	superieur( tab+1, taille-1, grand);
+}
+	
+int main(int argc, char** argv){
+	long int val;
+	int i;
+	long int* tab= (long int*) malloc(argc*sizeof(long int));
+	for (i = 1; i < argc; i++){
+		val = strtol(argv[i],NULL,10);
+		tab[i-1] = val;
+	}
+	val = superieur( tab+1, argc-1, tab[0]);
+	printf("%ld\n",val);
+	return EXIT_SUCCESS;
+}

DEV1.1/TP27/culmination.c

@@ -0,0 +1,24 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/*la variable grand lors du début du programme est la première valeur du tableau
+et le tableau ne contient pas son premier élément*/
+int superieur(long int tab[], int taille, long int grand){
+	if (taille < 1)
+		return grand;
+	else if (tab[0] > grand)
+		grand = tab[0];
+	return superieur( tab[]+1, taille-1, grand);
+	
+int main(int argc, char** argv){
+	long int val;
+	int i;
+	log int tab[argc];
+	for (i = 1; i < argc; i++){
+		val = strtol(argv[i]);
+		tab[i-1] = val;
+	}
+	val = superieur( tab[]+1, argc-1, tab[0]);
+	printf("%ld\n",val);
+	return EXIT_SUCCESS;

DEV1.1/TP28/Makefile

@@ -0,0 +1,20 @@
+but : pile
+
+OFILES = main.o\
+		chaine.o\
+
+CC = gcc
+
+CFLAGS =  -Wall -ansi -pedantic -g
+
+main.o : chaine.h 
+
+chaine.o : chaine.h
+
+pile : $(OFILES)
+		$(CC) $(CFLAGS) -o pile $(OFILES) 
+
+clean :
+	-rm -f $(OFILES) pile
+
+.PHONY : but clean

DEV1.1/TP28/chaine.c

@@ -1,28 +1,37 @@
 #include <stdio.h>
 #include <stdlib.h>
+#include "chaine.h"
 
-struct maillon_s {
-    char valeur;
-    struct maillon_s* suivant;
-};
-typedef struct maillon_s maillon ;
-
-void push(char nouv, maillon* debut){
+void push(char nouv, maillon** debut){
     maillon* m = (maillon*) malloc (sizeof(maillon));
     m->valeur = nouv;
     if (debut == NULL)
         m->suivant = NULL;
     else
-        m->suivant = debut;
-    debut = m;
+        m->suivant = *debut;
+    *debut = m;
 }
 
-void pop(maillon* debut){
-    maillon* m = (maillon*) malloc (sizeof(maillon));
-    m->valeur = nouv;
-    if (debut == NULL)
-        m->suivant = NULL;
+double pop(maillon** debut){
+    maillon m = **debut;
+    free(*debut);
+    if (m.suivant == NULL)
+        *debut = NULL;
     else
-        m->suivant = debut;
-    debut = m;
+        *debut = m.suivant;
+    return m.valeur;
+}
+
+int empty(const maillon* debut){
+    return debut == NULL;
+}
+
+double top (const maillon* debut){
+    return debut->valeur;
+}
+
+void clear (maillon** debut){
+    while (empty(*debut)){
+        pop(debut);
+    }
 }

DEV1.1/TP28/chaine.h

@@ -0,0 +1,14 @@
+#ifndef CHAINE_H
+#define CHAINE_H
+
+struct maillon_s {
+    char valeur;
+    struct maillon_s* suivant;
+};
+typedef struct maillon_s maillon ;
+
+void push(char nouv, maillon** debut);
+double pop(maillon** debut);
+int empty(const maillon* debut);
+
+#endif

DEV1.1/TP28/extra.c

@@ -0,0 +1,14 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "extra.h"
+#include "chaine.h"
+
+double top (const maillon* debut){
+    return debut->valeur;
+}
+
+void clear (maillon** debut){
+    while (empty(*debut)){
+        pop(debut);
+    }
+}

DEV1.1/TP28/extra.h

@@ -0,0 +1,7 @@
+#ifndef EXTRA_H
+#define EXTRA_H
+
+double top (const maillon* debut);
+void clear (maillon** debut);
+
+#endif

DEV1.1/TP28/main.c

@@ -0,0 +1,40 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "chaine.h"
+#include "extra.h"
+
+int main(void){
+    char op, valeur;
+    maillon* debut = NULL;
+    printf("La pile attend vos ordres\n");
+    printf("> ");
+    op = getchar();
+    while (op != 'q'){
+        if (op == '-'){
+            if (empty(debut)){
+                printf("La pile est vide !\n");
+                printf("> ");
+            }else{
+                valeur = pop(&debut);
+                printf("Le caractère %c a été supprimé\n", valeur);
+                printf("> ");
+            }
+        }else if (op == '+'){
+            valeur = getchar();
+            printf("Le caractère %c a été ajouté\n", valeur);
+            push(valeur, &debut);
+            printf("> ");
+        }else if (op == '/'){
+            clear(&debut);
+            printf("La pile est vide !\n");
+            printf("> ");
+        }else if (op == '='){
+            valeur = top(debut);
+            printf("Le caractère le plus récent est %c\n", valeur);
+            printf("> ");
+        }
+        op = getchar();
+    } 
+    printf("au revoir\n");
+    return EXIT_SUCCESS;
+}

DEV2.1/Graphique/Bouton.java

@@ -0,0 +1,21 @@
+import javax.swing.*;
+import java.awt.*;
+
+public class Bouton {
+  public static void main(String[] args) {
+    JFrame fenetre = new JFrame();
+    fenetre.setSize(500, 300);
+    fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+    JButton bouton = new JButton("bonjour");
+    JButton bouton1 = new JButton("bonsoir");
+    JButton bouton2 = new JButton("aurevoir");
+    JButton bouton3 = new JButton("bientôt");
+    JButton bouton4 = new JButton("salut");
+    fenetre.add(bouton, BorderLayout.NORTH);
+    fenetre.add(bouton1, BorderLayout.EAST);
+    fenetre.add(bouton2, BorderLayout.WEST);
+    fenetre.add(bouton3, BorderLayout.SOUTH);
+    fenetre.add(bouton4, BorderLayout.CENTER);
+    fenetre.setVisible(true);
+  }
+}

DEV2.1/Graphique/Choix.java

@@ -0,0 +1,21 @@
+import javax.swing.*;
+import java.awt.*;
+
+public class Choix {
+  public static void main(String[] args) {
+    JFrame fenetre = new JFrame();
+    fenetre.setSize(500, 300);
+    fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+    JRadioButton etiquette = new JRadioButton("Gryffondor");
+    JRadioButton etiquette1 = new JRadioButton("Serdaigle");
+    JRadioButton etiquette2 = new JRadioButton("Serpantard");
+    ButtonGroup btn = new ButtonGroup();
+    btn.add(etiquette);
+    btn.add(etiquette1);
+    btn.add(etiquette2);
+    fenetre.add(etiquette, BorderLayout.NORTH);
+    fenetre.add(etiquette1, BorderLayout.CENTER);
+    fenetre.add(etiquette2, BorderLayout.SOUTH);
+    fenetre.setVisible(true);
+  }
+}

DEV2.1/Graphique/Saisie.java

@@ -0,0 +1,23 @@
+import javax.swing.*;
+import java.awt.*;
+import java.awt.Color;
+
+public class Saisie {
+  public static void main(String[] args) {
+    Color vert = new Color(0,255,0);
+    Color noir = new Color(0,0,0);
+    Color gris = new Color(127,127,127);
+    JFrame fenetre = new JFrame();
+    fenetre.setSize(500, 300);
+    fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+    JTextField etiquette = new JTextField("bonjour ça va ?");
+    JTextArea etiquette2 = new JTextArea("bonjour tout va bien ?");
+    etiquette.setForeground(vert);
+    etiquette.setBackground(gris);
+    etiquette2.setForeground(vert);
+    etiquette2.setBackground(noir);
+    fenetre.add(etiquette, BorderLayout.SOUTH);
+    fenetre.add(etiquette2, BorderLayout.CENTER);
+    fenetre.setVisible(true);
+  }
+}

DEV2.1/Graphique/Sirocco.java

@@ -0,0 +1,14 @@
+import javax.swing.*;
+import java.awt.*;
+
+public class Sirocco {
+  public static void main(String[] args) {
+    JFrame fenetre = new JFrame();
+    fenetre.setSize(500, 300);
+    fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+    JLabel etiquette = new JLabel("Sirocco");
+    etiquette.setHorizontalAlignment(JLabel.RIGHT);
+    fenetre.add(etiquette, BorderLayout.NORTH);
+    fenetre.setVisible(true);
+  }
+}

DEV2.1/Mise_page/Choix.java

@@ -0,0 +1,26 @@
+import javax.swing.*;
+import java.awt.*;
+
+public class Choix {
+  public static void main(String[] args) {
+    JFrame fenetre = new JFrame();
+    fenetre.setSize(500, 300);
+    fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+    GridLayout gestionnaire = new GridLayout(4, 1);
+    fenetre.setLayout(gestionnaire);
+    JRadioButton etiquette = new JRadioButton("Gryffondor");
+    JRadioButton etiquette1 = new JRadioButton("Serdaigle");
+    JRadioButton etiquette2 = new JRadioButton("Serpantard");
+    JRadioButton etiquette3 = new JRadioButton("Poufsouffle");
+    ButtonGroup btn = new ButtonGroup();
+    btn.add(etiquette);
+    btn.add(etiquette1);
+    btn.add(etiquette2);
+    btn.add(etiquette3);
+    fenetre.add(etiquette);
+    fenetre.add(etiquette1);
+    fenetre.add(etiquette2);
+    fenetre.add(etiquette3);
+    fenetre.setVisible(true);
+  }
+}

DEV2.1/Mise_page/Damier.java

@@ -0,0 +1,23 @@
+import javax.swing.*;
+import java.awt.*;
+import java.awt.Color;
+
+public class Damier {
+  public static void main(String[] args) {
+    Color blanc = new Color(255,255,255);
+    Color cyan = new Color(0,255,255);
+    Color tab[] = {blanc,cyan};
+    int l = Integer.parseInt(args[0]);
+    JFrame fenetre = new JFrame();
+    fenetre.setSize(500, 300);
+    fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+    GridLayout gestionnaire = new GridLayout(l, l);
+    fenetre.setLayout(gestionnaire);
+    JTextArea block = new JTextArea();
+    for (int i=0; i<(l*l); i++){
+        block.setBackground(tab[i%2]);
+        fenetre.add(block);
+    }
+    fenetre.setVisible(true);
+  }
+}

DEV2.1/introduction/Bonjour.java

@@ -0,0 +1,17 @@
+/**
+* Cette classe est une simple coquille pour recevoir la méthode principale
+*
+* @version 1.1 09 March 2014
+* @author Luc Hernandez
+*/
+public class Bonjour {
+ 
+  /**
+  * Affiche «Bonjour !»
+  *
+  * @param args la liste des arguments de la ligne de commande (inutilisée ici)
+  */
+  public static void main(String[] args) {
+    System.out.println("Bonjour !");
+  }
+}

DEV2.1/introduction/Grille.java

@@ -0,0 +1,32 @@
+import java.util.Arrays;
+/**
+* Cette classe est une simple coquille pour recevoir la méthode principale
+*
+* @version 1.1 09 March 2014
+* @author Luc Hernandez
+*/
+public class Grille {
+ 
+  /**
+  * Affiche «Grille !»
+  *
+  * @param args la liste des arguments de la ligne de commande (inutilisée ici)
+  */
+  public static void main(String[] args) {
+    int n=Integer.parseInt(args[0]), i, j;
+    System.out.print("+");
+    for (i=0;i<n;i++){
+        System.out.print("-+");
+    }
+    for (j=0;j<n;j++){
+        System.out.print("\n|");
+        for (i=0;i<n;i++){
+            System.out.print(" |");
+        }
+        System.out.print("\n+");
+        for (i=0;i<n;i++){
+            System.out.print("-+");
+        }
+    }
+  }
+}

DEV2.1/introduction/Somme.java

@@ -0,0 +1,21 @@
+/**
+* Cette classe est une simple coquille pour recevoir la méthode principale
+*
+* @version 1.1 09 March 2014
+* @author Luc Hernandez
+*/
+public class Somme {
+ 
+  /**
+  * Affiche «Somme !»
+  *
+  * @param args la liste des arguments de la ligne de commande (inutilisée ici)
+  */
+  public static void main(String[] args) {
+    int n=0;
+    for (String value : args){
+        n = n + Integer.parseInt(value);
+    }
+    System.out.println("Somme: "+n);
+  }
+}

DEV2.1/introduction/Tri.java

@@ -0,0 +1,27 @@
+import java.util.Arrays;
+/**
+* Cette classe est une simple coquille pour recevoir la méthode principale
+*
+* @version 1.1 09 March 2014
+* @author Luc Hernandez
+*/
+public class Tri {
+ 
+  /**
+  * Affiche «Tri !»
+  *
+  * @param args la liste des arguments de la ligne de commande (inutilisée ici)
+  */
+  public static void main(String[] args) {
+    int tab[] = new int[args.length];
+    int i=0;
+    for (String value : args){
+        tab[i] = Integer.parseInt(value);
+        i++;
+    }
+    Arrays.sort(tab);
+    for (int value : tab){
+        System.out.println(value);
+    }
+  }
+}

DEV2.1/introduction/argument.java

@@ -0,0 +1,19 @@
+/**
+* Cette classe est une simple coquille pour recevoir la méthode principale
+*
+* @version 1.1 09 March 2014
+* @author Luc Hernandez
+*/
+public class argument {
+ 
+  /**
+  * Affiche «argument !»
+  *
+  * @param args la liste des arguments de la ligne de commande (inutilisée ici)
+  */
+  public static void main(String[] args) {
+    for (String value : args){
+        System.out.println("Bonjour "+value);
+    }
+  }
+}

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;
+}