push main.c

main.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+
+int is_div(int number, int i) { // Vérifie si i est un diviseur de number.
+    return (number % i == 0) ; // revoi 0 si le nombre n'est pas divisible par i et 1 si il est divisible
+}
+
+int is_prime(int number) { // Vérifie si number est un nombre premier. Return 1 si il est premier, 0 sinon
+    if (number != 2 ) {
+        if (number % 2 == 0) { // si il n'est pas divisible par deux pas besoin de regarder les nombres paires
+            return 0 ;
+        }
+    }
+    for (int i = 3 ; i <= number / 2 ; i = i + 2) { //regarde les differents nombres pouvant etre diviser number
+        if (is_div(number,i) == 1) { // si i peut diviser number
+            return 0 ; //renvoi 0 => FAUX
+        }
+    }
+    return 1 ; //sinon => VRAI
+}
+
+// travail en likendList
+typedef struct node { // creation d'un node
+    struct node *next; // prochain
+    int *nombre_premier; // nombre_premier
+}node_t;
+
+typedef struct list {
+    int size; // taille de mon noeud
+    node_t *head ; // tete de mon noeud
+} list_t;
+
+list_t *init_node(int value) { // initialsier ma liste avec un premier noued
+
+    list_t *liste = malloc(sizeof(*liste)) ;
+    struct node *nouveau = malloc(sizeof(*nouveau)) ; // allouer de la memoire pour nouveau
+    if (nouveau == NULL || liste == NULL) { // si malloc ne focntionne pas
+        return NULL ;
+    }
+    nouveau -> nombre_premier = (int *) value; // donne la valeur au noued
+    nouveau -> next = NULL ; // suivant est NULL
+    liste -> head = nouveau ; // donne une valeur a head
+    liste -> size = liste -> size + 1 ;
+    return liste ;
+}
+
+void add_node(list_t *list, int value)  { // si ne fonctionne pas 1 sinon 0
+    struct node *nouveau = malloc(sizeof(*nouveau)) ;  // allouer de la memoire pour nouveau
+    if (nouveau == NULL) { // si malloc rate
+        return ;
+    }
+    if (list == NULL) {
+        return;
+    }
+    nouveau -> nombre_premier = (int *) value ; // donne une valuer a nouveau
+    nouveau -> next = list -> head ; // ajoute son pointeur
+    list -> head = nouveau ;
+    list -> size = list -> size + 1 ; // augmente la taille de la liste
+}
+
+
+list_t * prime_divs(int number) {
+    // creation d'une stack pour enmagasiner les différents nombres premiers
+    int premier = 0 ; //pour que se soit le premier de La liste
+    list_t *list = NULL ;
+    for (int i = 2 ; i <= number / 2 ; i++) {
+        if (is_prime(i) == 1 && is_div(number , i) == 1) { // si i est premier et divise number
+            if (premier == 0) { // si c'est le premier nombre initialise ma liste
+                list = init_node(i) ; // j'initialise ma liste
+                premier = 1 ; // ne reviens plus ici
+            }
+            else {
+                add_node(list,i) ; // je le mets dans ma liste
+            }
+        }
+    }
+    return list ;
+}
+
+void afficherListe(list_t *liste) { // afficher la liste
+
+    if (liste == NULL) {
+        exit(EXIT_FAILURE);
+    }
+
+    node_t *noued = liste -> head;
+
+    while (noued != NULL)
+    {
+        int val = (int) noued->nombre_premier;
+        printf("%d ", val);
+        noued = noued -> next;
+    }
+    printf("NULL\n");
+}
+
+int ecrire_dans_fichier(char *input, char *output) { // => en utilisant FILE on a plusieurs fonctions qui facilitenet la vie
+
+    FILE *fichier_entree = NULL ;
+    fichier_entree = fopen(input, "r") ;
+    // "r+": lecture et écriture. Vous pourrez lire et écrire dans le fichier.
+    // Le fichier doit avoir été créé au préalable.
+    FILE *fichier_sortie = NULL ;
+    fichier_sortie = fopen(output, "w+") ;
+    //"w+": lecture et écriture, avec suppression du contenu au préalable.
+    // Le fichier est donc d'abord vidé de son contenu, vous pouvez y écrire,
+    // et le lire ensuite. Si le fichier n'existe pas, il sera créé.
+    if (fichier_entree == NULL || fichier_sortie == NULL) { // si ca ne va pas
+        return 1;
+    }
+
+    char *line = malloc(sizeof(char[50])) ; // j'alloue de la memoire pour line
+    while (fgets (line, sizeof(char[50]), fichier_entree) != NULL) {
+
+        int nombre = strtol(line,NULL,0) ;
+        // Cette fonction, signifiant string to long, permet de transformer une chaîne de caractères, contenant
+        // la représentation textuelle d'un entier, en un entier type long.
+
+        //void* mapping = malloc(sizeof(char[50])) ;
+        /*Établir ne projection en mémoire des fichiers ou des périphériques   (
+        en qq sorte le malloc des fichier
+        argument :
+        1er => L'adresse de départ de la nouvelle projection
+        2eme => longueur
+        3eme => PROT_WRITE On peut écrire dans la zone mémoire.
+        4eme => MAP_SHARED Partager cette projection.
+        5eme => fihcier
+        6eme => ?
+        mmap() renvoie un pointeur sur la zone de mémoire, s'il réussit. En cas d'échec il retourne la valeur MAP_FAILED (c'est-à-dire (void *) -1)
+        http://manpagesfr.free.fr/man/man2/mmap.2.html
+        */
+
+        //memcpy(mapping,(char *) nombre, sizeof(char[50])) ;
+        /*void * memcpy (void * dest, const void * src, size_t n) copie n caractères de la zone mémoire src vers la zone mémoire dest .
+        argument :
+        dest - Il s'agit du pointeur vers le tableau de destination où le contenu doit être copié, transtypé en un pointeur de type void *.
+        src - Il s'agit d'un pointeur vers la source des données à copier, transtypées en un pointeur de type void *.
+        n - Il s'agit du nombre d'octets à copier.
+        Cette fonction renvoie un pointeur vers la destination
+        https://www.tutorialspoint.com/c_standard_library/c_function_memcpy.htm
+        */
+
+        fprintf(fichier_sortie, "%d ",nombre) ; // Ecriture dans le fichier
+        list_t *liste = prime_divs(nombre) ;
+        if (liste == NULL) {
+            fputc('\n', fichier_sortie);
+            continue ;
+        }
+        else {
+            node_t *noued = liste -> head;
+            while (noued != NULL)
+            {
+                //char *nombre_devient_char = malloc(sizeof(char[50]));
+                //memcpy(nombre_devient_char,(char*) noued -> nombre_premier, sizeof(char[50])) ;
+                fprintf(fichier_sortie, "%d ",(int) noued -> nombre_premier) ;
+                /* https://www.geeksforgeeks.org/fprintf-in-c/
+                 * int fprintf (FICHIER * fptr, const char * str, ...);
+                 * fprintf est utilisé pour imprimer le contenu dans un fichier au lieu de la console standard.
+                 */
+                noued = noued -> next;
+            }
+            fputc('\n', fichier_sortie);
+        }
+    }
+    fclose(fichier_entree) ;
+    fclose(fichier_sortie) ;
+    return 0 ;
+}
+int main(int argc, char *argv[]) {
+    // test pour is_div(int number, int i)
+    int number = 10 ;
+    int number1 = 11 ;
+    int i = 2 ;
+    printf("%d\n",is_div(number,i)) ; // 1
+    printf("%d\n",is_div(number1,i)) ; // 0
+    // test pour is_prime(int number)
+    int number2 = 1498498411 ;
+    int number3 = 5 ;
+    int number4 = 14545144 ;
+    printf("%d\n",is_prime(number2)) ; // 0
+    printf("%d\n",is_prime(number3)) ; // 1
+    printf("%d\n",is_prime(number4)) ; // 0
+    //prime divis
+    int numbre5 = 14 ;
+    list_t *liste = prime_divs(numbre5) ;
+    // je ne vois pas pq ca ne fonctionne pas
+    afficherListe(liste) ;
+    int oui = ecrire_dans_fichier("input.txt","output.txt") ;
+    printf("%d",oui) ; //0
+    return 0;
+}