update

DEV.1.1/CM3TEST/cm3.1.c

@@ -0,0 +1,46 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* Fonction pour traiter l'image */
+void modifier_image_pgm(const char *nom_fichier) {
+    FILE *fichier;
+    char ligne[256];
+    int largeur, hauteur, niveaux, x, y;
+    
+    fichier = fopen(nom_fichier, "r+");
+    if (fichier == NULL) {
+        fprintf(stderr, "Erreur: Impossible d'ouvrir le fichier\n");
+        exit(EXIT_FAILURE);
+    }
+
+    /* Lire l'en-tête du fichier PGM */
+    fgets(ligne, sizeof(ligne), fichier); /* Lire le format (P2) */
+    fgets(ligne, sizeof(ligne), fichier); /* Lire le commentaire */
+    fscanf(fichier, "%d %d", &largeur, &hauteur);
+    fscanf(fichier, "%d", &niveaux);
+
+    /* Modifier les pixels d'intensité 3 au centre de l'image */
+    for (y = 0; y < hauteur; y++) {
+        for (x = 0; x < largeur; x++) {
+            int pixel;
+            fscanf(fichier, "%d", &pixel);
+            if (pixel == 3 && x > 0 && x < largeur - 1 && y > 0 && y < hauteur - 1) {
+                fseek(fichier, -2, SEEK_CUR);
+                fprintf(fichier, "5 ");
+            }
+        }
+    }
+
+    fclose(fichier);
+}
+
+int main(int argc, char *argv[]) {
+    if (argc != 2) {
+        fprintf(stderr, "Usage: %s fichier.pgm\n", argv[0]);
+        return EXIT_FAILURE;
+    }
+
+    modifier_image_pgm(argv[1]);
+    return EXIT_SUCCESS;
+}

DEV.1.1/CM3TEST/cm3.2.c

@@ -0,0 +1,37 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+/* Fonction récursive pour trouver le maximum */
+int trouver_maximum(int n, int valeurs[]) {
+    if (n == 1) {
+        return valeurs[0];
+    }
+    int max_suivant = trouver_maximum(n - 1, valeurs + 1);
+    return (valeurs[0] > max_suivant) ? valeurs[0] : max_suivant;
+}
+
+int main(int argc, char *argv[]) {
+    int i, n;
+    int *valeurs;
+
+    if (argc < 2) {
+        fprintf(stderr, "Usage: %s nombre1 nombre2 ...\n", argv[0]);
+        return EXIT_FAILURE;
+    }
+
+    n = argc - 1;
+    valeurs = (int*)malloc(n * sizeof(int));
+    if (valeurs == NULL) {
+        fprintf(stderr, "Erreur d'allocation mémoire\n");
+        return EXIT_FAILURE;
+    }
+
+    for (i = 0; i < n; i++) {
+        valeurs[i] = atoi(argv[i + 1]);
+    }
+
+    printf("%d\n", trouver_maximum(n, valeurs));
+
+    free(valeurs);
+    return EXIT_SUCCESS;
+}

DEV.1.1/CM3TEST/cm3.3.c

@@ -0,0 +1,89 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* Structure d'un nœud de la liste chaînée */
+typedef struct Node {
+    int digit;
+    struct Node *next;
+} Node;
+
+/* Fonction pour ajouter un chiffre à la fin de la liste chaînée */
+Node* ajouter_chiffre(Node *head, int digit) {
+    Node *new_node = (Node*)malloc(sizeof(Node));
+    if (new_node == NULL) {
+        fprintf(stderr, "Erreur d'allocation memoire\n");
+        exit(EXIT_FAILURE);
+    }
+    new_node->digit = digit;
+    new_node->next = NULL;
+    if (head == NULL) {
+        return new_node;
+    }
+    Node *temp = head;
+    while (temp->next != NULL) {
+        temp = temp->next;
+    }
+    temp->next = new_node;
+    return head;
+}
+
+/* Fonction pour convertir une chaîne en liste chaînée */
+Node* convertir_en_liste(const char *nombre) {
+    Node *head = NULL;
+    int i;
+    for (i = 0; nombre[i] != '\0'; i++) {
+        head = ajouter_chiffre(head, nombre[i] - '0');
+    }
+    return head;
+}
+
+/* Fonction pour afficher la liste chaînée */
+void afficher_liste(Node *head) {
+    while (head != NULL) {
+        printf("%d", head->digit);
+        head = head->next;
+    }
+}
+
+/* Fonction pour additionner deux listes chaînées */
+Node* additionner_listes(Node *l1, Node *l2) {
+    Node *resultat = NULL;
+    int retenue = 0;
+
+    while (l1 != NULL || l2 != NULL || retenue) {
+        int somme = retenue;
+        if (l1 != NULL) {
+            somme += l1->digit;
+            l1 = l1->next;
+        }
+        if (l2 != NULL) {
+            somme += l2->digit;
+            l2 = l2->next;
+        }
+        resultat = ajouter_chiffre(resultat, somme % 10);
+        retenue = somme / 10;
+    }
+    return resultat;
+}
+
+/* Fonction principale */
+int main(int argc, char *argv[]) {
+    Node *num1;
+    Node *num2;
+    Node *somme;
+
+    if (argc != 3) {
+        fprintf(stderr, "Usage: %s nombre1 nombre2\n", argv[0]);
+        return EXIT_FAILURE;
+    }
+
+    num1 = convertir_en_liste(argv[1]);
+    num2 = convertir_en_liste(argv[2]);
+
+    somme = additionner_listes(num1, num2);
+    afficher_liste(somme);
+    printf("\n");
+
+    return EXIT_SUCCESS;
+}

DEV.1.1/CM3TEST/cm3B.1.c

@@ -0,0 +1,87 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#define TEMP_FILE_NAME "tempfile.tmp"
+#define MESSAGE "Kilroy was here\n"
+
+int main(int argc, char *argv[]) {
+    FILE *file, *tempFile;
+    char buffer[1024];
+    size_t bytesRead;
+    size_t messageLength = 0;
+    const char *messagePtr = MESSAGE;
+
+    while (messagePtr[messageLength] != '\0') {
+        messageLength++;
+    }
+
+    /* Vérification des arguments */
+    if (argc != 2) {
+        fprintf(stderr, "Usage: %s <chemin_du_fichier>\n", argv[0]);
+        return EXIT_FAILURE;
+    }
+
+    /* Ouverture du fichier original en lecture-écriture */
+    file = fopen(argv[1], "r+");
+    if (file == NULL) {
+        perror("Erreur d'ouverture du fichier");
+        return EXIT_FAILURE;
+    }
+
+    /* Création d'un fichier temporaire */
+    tempFile = tmpfile();
+    if (tempFile == NULL) {
+        perror("Erreur de création du fichier temporaire");
+        fclose(file);
+        return EXIT_FAILURE;
+    }
+
+    /* Écriture du message dans le fichier temporaire */
+    if (fwrite(MESSAGE, 1, messageLength, tempFile) != messageLength) {
+        perror("Erreur d'écriture dans le fichier temporaire");
+        fclose(file);
+        fclose(tempFile);
+        return EXIT_FAILURE;
+    }
+
+    /* Copier le contenu du fichier original dans le fichier temporaire */
+    while ((bytesRead = fread(buffer, 1, sizeof(buffer), file)) > 0) {
+        if (fwrite(buffer, 1, bytesRead, tempFile) != bytesRead) {
+            perror("Erreur d'écriture dans le fichier temporaire");
+            fclose(file);
+            fclose(tempFile);
+            return EXIT_FAILURE;
+        }
+    }
+
+    /* Retour au début des fichiers */
+    rewind(tempFile);
+    rewind(file);
+
+    /* Copier le contenu du fichier temporaire dans le fichier original */
+    while ((bytesRead = fread(buffer, 1, sizeof(buffer), tempFile)) > 0) {
+        if (fwrite(buffer, 1, bytesRead, file) != bytesRead) {
+            perror("Erreur d'écriture dans le fichier original");
+            fclose(file);
+            fclose(tempFile);
+            return EXIT_FAILURE;
+        }
+    }
+
+    /* Tronquer le fichier au cas où il serait plus grand que le contenu écrit */
+    if (fflush(file) != 0 || ftruncate(fileno(file), ftell(file)) != 0) {
+        perror("Erreur lors de la troncation du fichier");
+        fclose(file);
+        fclose(tempFile);
+        return EXIT_FAILURE;
+    }
+
+    /* Fermeture des fichiers */
+    fclose(file);
+    fclose(tempFile);
+
+    return EXIT_SUCCESS;
+}
+
+/*gcc -ansi -pedantic -o graffiti graffiti.c
+./graffiti chemin_du_fichier*/

DEV.1.1/CM3TEST/cm3B.2.c

@@ -0,0 +1,32 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+/* Fonction récursive pour calculer le nombre de chiffres */
+int nombre_de_chiffres(unsigned int n) {
+    /* Cas de base : un seul chiffre */
+    if (n < 10) {
+        return 1;
+    }
+    /* Appel récursif avec la division par 10 */
+    return 1 + nombre_de_chiffres(n / 10);
+}
+
+/* Fonction principale pour tester */
+int main(void) {
+    /* Cas de test */
+    unsigned int valeurs[] = {0, 999, 10000};
+    int resultats_attendus[] = {1, 3, 5};
+    int i, resultat;
+
+    printf("Test de la fonction nombre_de_chiffres:\n");
+    for (i = 0; i < 3; i++) {
+        resultat = nombre_de_chiffres(valeurs[i]);
+        printf("Nombre de chiffres de %u : %d (Attendu : %d)\n",
+               valeurs[i], resultat, resultats_attendus[i]);
+        if (resultat != resultats_attendus[i]) {
+            printf("Erreur : le résultat est incorrect pour %u\n", valeurs[i]);
+        }
+    }
+
+    return EXIT_SUCCESS;
+}

DEV.1.1/CM3TEST/cm3B.3.c

@@ -0,0 +1,78 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+/* Structure représentant un maillon d'une liste chaînée */
+typedef struct Maillon {
+    double valeur;
+    struct Maillon *suivant;
+} Maillon;
+
+/* Fonction pour afficher une liste chaînée */
+void afficher_liste(Maillon *tete) {
+    Maillon *courant = tete;
+    while (courant != NULL) {
+        printf("%lf ", courant->valeur);
+        courant = courant->suivant;
+    }
+    printf("\n");
+}
+
+/* Fonction pour ajouter une valeur dans une liste triée */
+Maillon *ajouter_valeur(Maillon *tete, double valeur) {
+    /* Création d'un nouveau maillon */
+    Maillon *nouveau = (Maillon *)malloc(sizeof(Maillon));
+    if (nouveau == NULL) {
+        perror("Erreur d'allocation mémoire");
+        exit(EXIT_FAILURE);
+    }
+    nouveau->valeur = valeur;
+    nouveau->suivant = NULL;
+
+    /* Si la liste est vide ou si la valeur doit être ajoutée en tête */
+    if (tete == NULL || valeur <= tete->valeur) {
+        nouveau->suivant = tete;
+        return nouveau;
+    }
+
+    /* Recherche de l'emplacement pour insérer la nouvelle valeur */
+    Maillon *courant = tete;
+    while (courant->suivant != NULL && courant->suivant->valeur < valeur) {
+        courant = courant->suivant;
+    }
+
+    /* Insertion du nouveau maillon */
+    nouveau->suivant = courant->suivant;
+    courant->suivant = nouveau;
+
+    return tete;
+}
+
+/* Programme principal */
+int main(int argc, char *argv[]) {
+    /* Vérification des arguments */
+    if (argc < 2) {
+        fprintf(stderr, "Usage: %s <reel1> <reel2> ... <reelN>\n", argv[0]);
+        return EXIT_FAILURE;
+    }
+
+    Maillon *liste = NULL;
+
+    /* Conversion des arguments en double et insertion dans la liste */
+    for (int i = 1; i < argc; i++) {
+        double valeur = atof(argv[i]);
+        liste = ajouter_valeur(liste, valeur);
+    }
+
+    /* Affichage de la liste triée */
+    afficher_liste(liste);
+
+    /* Libération de la mémoire */
+    Maillon *temp;
+    while (liste != NULL) {
+        temp = liste;
+        liste = liste->suivant;
+        free(temp);
+    }
+
+    return EXIT_SUCCESS;
+}