Newer
Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
#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;
}