Discussion :

[Matt_Houston]

C'est vrai, l'une des différences étant que la norme ne requiert pas que *scanf lève ERANGE en cas de dépassement de capacité.

À titre d'exemple, voici comment faire en sorte que les deux méthodes aient un comportement similaire :

Code conv.c :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include <errno.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
 
int toui64_scanf(uint64_t *num, const char *s) {
    int c;
    uint64_t n;
    const int ret = sscanf(s, "%" SCNu64 "%n", &n, &c);
    if (ret != 1)
        return 1;
 
    if ((size_t)c != strlen(s))
        return 2;
 
    *num = n;
 
    return 0;
}
 
int toui64_strtoul(uint64_t *num, const char *s) {
    _Static_assert(sizeof(unsigned long long) <= sizeof(uint64_t), "possible overflow");
 
    errno = 0;
    char *end;
    const uint64_t n = (uint64_t)strtoull(s, &end, 10);
    if (errno == ERANGE)
        return 1;
 
    if (end - s != (ssize_t)strlen(s))
        return 2;
 
    *num = n;
    errno = 0;
 
    return 0;
}
 
void dump(int (*toui64)(uint64_t *, const char *), const char *from[], size_t size) {
    uint64_t u64 = UINT64_C(0);
    for (size_t i = 0; i < size; ++i) {
        const int ret = toui64(&u64, from[i]);
 
        printf("  %10s: ", from[i]);
 
        if (ret)
            printf("parsing failed\n");
        else
            printf("successfully parsed %" PRIu64 "\n", u64);
    }
}
 
 
const char *test[] = {
    "64junk",
    "zzz64junk",
    ";64",
    "..64.2",
    "3.141592",
    "18",
    "abc",
    "-18",
    "-18a42"
};
 
int main(int argc, char *argv[]) {
    (void)argc; (void)argv;
 
    puts("sscanf:");
    dump(toui64_scanf, test, sizeof test / sizeof *test);
 
    puts("\nstrtoull:");
    dump(toui64_strtoul, test, sizeof test / sizeof *test);
 
    return 0;
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
$ gcc -std=c11 -pedantic -Wall -Wextra conv.c
$ ./a.out
sscanf:
      64junk: parsing failed
   zzz64junk: parsing failed
         ;64: parsing failed
      ..64.2: parsing failed
    3.141592: parsing failed
          18: successfully parsed 18
         abc: parsing failed
         -18: successfully parsed 18446744073709551598
      -18a42: parsing failed
 
strtoull:
      64junk: parsing failed
   zzz64junk: parsing failed
         ;64: parsing failed
      ..64.2: parsing failed
    3.141592: parsing failed
          18: successfully parsed 18
         abc: parsing failed
         -18: successfully parsed 18446744073709551598
      -18a42: parsing failed

[Jaenne]

Salut, bon, strtoull, toujours pas :-/ remplacée par atoll.

Par contre argc-argv c'est bon !

Ça veut dire quoi OP ?

Ne désespérez pas et continuez de me donnez des conseils. Je ne suis pas de ceux qui comprennent vite mais c'est pas grave, j'ai du temps libre :p
Je garde tout sous le coude. Merci encore.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include <stdio.h>
#include <stdlib.h>
#include "primesCalc.h"
 
int main (int argc, char* argv[]) {
 
	if (argc !=3){
		printf("\n\tNeeds 2 intergers :\n\t0 <= startInt <= endInt \n\n");
		return 0;
	}
 
	unsigned long long int start = atoll (argv[1]);
	unsigned long long int end = atoll (argv[2]);
	unsigned long long int testedNumber =1;
	unsigned long long int i = 0;
 
	start = conv (start);
	end = conv (end);
 
	if (end<start)
		end=start;
 
	printf("\nSearch primes from : %llu to %llu.\nIt could take less than a second or many hours !\n\n",start,end);
	for (testedNumber=start;testedNumber<=end;testedNumber++){
		if (testedNumber>4){
			if (primeTest(testedNumber)==1){
				//primes > 4.
				printf ("%llu ", testedNumber);
				i++;
			}
			else 
				printf(". ");
		}		
		else{
 			if (testedNumber>1 && testedNumber<=3){
				//2 and 3.
				printf ("%llu ", testedNumber);
				i++;
			}
			else 
				printf(". ");
		}
	}
	printf ("\n\nFrom %lld to %llu, %llu primes found.\n\n",start,end, i);
 	return 0;
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
 
unsigned int primeTest( unsigned long long int number) {
	unsigned long long int divisor =2;
	unsigned long long int modulo= 1 ;
	//To avoid waste of time.
	while (divisor <= number/2 && modulo !=0) {
		modulo = number%divisor;
		divisor++;
	}
	return (modulo!=0);
}
 
 
unsigned long long int conv(long long int number){
	if (number<0) 
		number*= -1 ;
	number = (unsigned long long int) number;
	return number;
}

[picodev]

Juste pour revenir sur un de tes commentaires dans le code «Pour eviter une perte de temps en calculs.»

Tu peux revoir ton algo, tu n'as pas besoin de tous les nombres entre 1 et n/2 pour tester la primalité de n, tu peux t'arrêter à √n. Quand n est impair tu peux ne pas tester un diviseur pair ...
Tu peux aussi remarquer que pour tout nombre premier supérieur ou égal à 5, un nombre ne peut être premier que si son modulo 6 vaut 1 ou 5. Cette remarque est valable aussi pour la boucle pour détecter un diviseur.

Tu peux aussi t'intéresser à d'autres algorithmes qui sont ultra rapides, comme par exemple un test de miller-rabin que tu rends déterministe.

OP = posteur originel = toi.

[Jaenne]

Ok merci. Je me trouvais super maligne avec mon calcul

Ce serait génial que ce programme travaille plus vite. Je prendrais le temps de regarder ça. On verra si j'arrive a tout mettre en place.

J'ai édité mon code pour tenter une traduction en anglais.

[Matt_Houston]

Tu peux ajouter d'autres algorithmes en tant que fonctions supplémentaires à ton programme, puis comparer les différents traitements.

Attention aux membres de la famille ato* qui ne détectent pas les erreurs de conversion. Tu peux alternativement utiliser / adapter les fonctions du programme que j'ai fourni, basées soit sur *scanf, soit sur strto*. Ces fonctions retournent zéro et modifient leur premier paramètre lorsque la conversion a réussi.