Bibm@th

Forum de mathématiques - Bibm@th.net

Bienvenue dans les forums du site BibM@th, des forums où on dit Bonjour (Bonsoir), Merci, S'il vous plaît...

Vous n'êtes pas identifié(e).

Répondre

Veuillez composer votre message et l'envoyer
Nom (obligatoire)

E-mail (obligatoire)

Message (obligatoire)

Programme anti-spam : Afin de lutter contre le spam, nous vous demandons de bien vouloir répondre à la question suivante. Après inscription sur le site, vous n'aurez plus à répondre à ces questions.

Quel est le résultat de l'opération suivante (donner le résultat en chiffres)?
quatre-vingt six plus soixante
Système anti-bot

Faites glisser le curseur de gauche à droite pour activer le bouton de confirmation.

Attention : Vous devez activer Javascript dans votre navigateur pour utiliser le système anti-bot.

Retour

Résumé de la discussion (messages les plus récents en premier)

LEG
Aujourd'hui 07:29:55

Suite du post ci-dessus:
Je suppose que la fonction range ne changerait rien à la place de enumérate, dans le but d'appeler les pi d'eratosne(n) afin d'utiliser les indices ['i] pour calculer les produit :
j = a * b
de sorte que lorsqu'un j a été calculé et qu'il est égal à j%30 == fam, puis on a calculé son index : soit pour a ou pour a et b suivant j est le carré de a.

Donc : a et b sont deux (premiers(n)) eratostene appelé, ils vont donc aller cribler....> n/30.

alors pourquoi ne pas mettre à 0 ces deux indices ['i] pour ne pas les rappeler...?
De sorte, que l'indice:  i +1 du [premier] suivant, si i +=1 est marqué 0 , on saute et on utilise l'indice suivant:
  i += 1, +=1, pour tout indice > 0.....non ?

En exemple:

for i,a in enumerate(premiers):

=
  {7, 11 13 17 19 23 29 31 37 41 43 47 53}  indice i +=1:
  {0, 1 , 2 , 3, 4 ,5 , 6 , 7, 8 , 9, 10,11, 12}

ce qui donnerait pour calculer  j:
i*i , i * i+1, i *j+2 qui %30 = fam
index de j //30 = 3 index de a et b,

a crible , puis b crible, on met leur deux indices à 0 ce qui donne
{0, 1 , 0 , 3, 4 ,5 , 6 , 7, 8 , 9, 10,11, 12} on réitère avec l'indice suivant qui est 1.
i*i qui %30 = fam
index de j //30 = 4 index de a , qui crible...>n/30 , on met son indices à 0 ce qui donne :

  {0, 0 , 0 , 3, 4 ,5 , 6 , 7, 8 , 9, 10,11, 12}; on réitère avec l'indice i +=1 suivant qui est 0 ; donc i += 1  indice 3
i*i  , i* i +1 , i * i+2 qui %30 = fam
index de j //30 = 13 .. index de aet b, , qui criblent...>n/30 , on met leurs indices à 0 ce qui donne :

{0, 0 , 0 , 0, 4 ,0 , 6 , 7, 8 , 9, 10,11, 12} ..etc on réitère...avec i = 4 qui serra un carré congru à 1 (mod30)

Pourquoi on peut supprimer les pi qui ont criblé , ou mettre leurs indices à 0 ...?

Tout simplement , pour fam = 1 fixée:

  pi = 7 , va parcourir les pi de Fam =13 , inversement 13 va parcourir les pi de Fam = 7:

Lorsqu'ils criblent ils marquent leur "conjoints" C...d'où on peut partir du carré de pi ou plus loin...pour ne pas revenir en arrière...Et donc , ne pas refaire des multiplications et index inutile...pour 3000: 18 au lieu de 72 ou 169...
Ex : je prend pi = 43 je fais i,a *b = 43*7 et index ...Alors que 7 en criblant a marqué d'un 0 sa cellule. ainsi que 37...d'où l'indice de 43 a été mis à 0 part 37, et l'indice de 53  mis à 0 par 17...lis ne peuvent donc pas être utilisé ensuite car ils ont déjà criblés...!
("Ce qui n'est pas faisable avec le Gcrible de Goldbach...car on part de l'indice du reste Ri.")

7 *13 ; 7*43; 7*73 ; 7* C+30 .....7 *C+30k
13 *37 , 13*67, 13 *97 ; 13 * C +30 .....13*C+30k....

11 *11 , va parcourir sa Fam = 11 +30k

17*23 vont parcourir fam 23+30k et 17+30k

19*19 ,va parcourir sa Fam = 19 +30k

29*29 ,va parcourir sa Fam = 29 +30k  et en dernier :

31*31 ,va parcourir sa Fam = 31 +30k qui est la fam 1+30k

c'est un résumé du GM (groupe multiplicatif)de l'algorithme nbpremier en c++ Mais qui par cette méthode serra optimiser au maximum...pour fam = 1 ou 19 ,il y a 6 couples de base car il y a les carrés de pi, et pour les autres 4 couples.

pour fam =7 , on aura : 7 *31 ..c+30k et inversement , 11* 17 ...c+30k ; 13 *19 ..c+30, et 23 *29 ..c+30k

etc..

LEG
Hier 21:07:35

j'ai bien compris ta modif pour supprimer des multiplications redondantes puisque par ex pour n = 24 000 000 000 il met 124 secondes aussi rapide que cribleG3Y.. Et encore il n'est pas optimisé..

car pour chaque début d'index on devrait faire partir les deux nombres premiers à la suite  a,b de sorte qu'il n'y aura plus à les utiliser cela fait cribler à partir de l'index du carrée de a au minimum ,  quand le produit n'est pas un carré de a et bien il y a: a et b = (j%30) == fam
et l'index j //30  est donné pour a et b...!

pour ta question ce n'est pas tout à fait la transcription de nbpremier en  c++ car on utilise pas l'appel des pi < sqrt n
on positionne le GM {7,11,13,17,19,23,29,31}...et on avance à petit pas avec des arrêts...

car si c'était le cas, il irait à donf...! c'est pour cela qu'il faut le faire en python puis on le transcrit en C++ si possible comme cela à été fait par Mr Parisse Bernard de l'univ de Grenoble  qui à vraiment été symp...de s'investir pour voir ce que l'on pouvait faire en c++ pour le crible Gcrible GtY...il l'a retranscrit en utilisant la mémoire iscas par copié collé...(mais j'ai rien compris....)

chez moi il est limité à 145 000 000 000 en 12 secondes......chez lui sous linux en 64bit il met 60 seconde pour 450 000 000 000
alors que nbpremier win32 chez moi je met 2h40....pour 450 Go, et 240 secondes pour 145 Go...

si on arrive à l'optimisé celui ci, il ira encore plus vite que crible G3Y donc 20 fois plus vite retranscrit en c++

c'est en faisant le Gcrible que je me suis rendu compte que mon nbpremier win 32 était loin d'être optimisé car il fait des aller retour sans arrêt ; du fait que l'on crible avec le groupe multiplicatif GM {7,11,13,17,19,23,29,31} et c'est ce groupe qui extrait les Pi puis les fait partir ...sous condition......Problème le groupe GM avance par petit pas....c'est redondant...

Voila pourquoi le but est de faire partir A et B à la suite ou A tout seul si j = A*A. , de sorte que chaque premier qui a cribler et bien il sort du crible comme je te l'ai expliqué plus Haut...

prenons n=3000 fam =1
donc liste des Pi = { 7,11,13,17,19,23,29,31,37,41,43,47 et 53}
regarde :
7*7 , 7*11 (7*13)% 30 = 1 ok index, ils partent cribler et sorte de liste Pi.suivant 11
(11*11)% 30 = 1 ok index, il part cribler par pas de a et b puis sorte de liste Pi. suivant 17 puisque 13 est sorti...!
17*17 , 17 *19 , (17*23)% 30 = 1 ok index, il partent cribler et sorte de liste Pi. suivant 19 ok [7.11.13.17.23 sont sortie]
(19*19)% 30 = 1 ok index, il part cribler et sorte de liste Pi. suivant 29 :
(29*29)% 30 = 1 ok index, il part cribler et sorte de liste Pi. suivant 31 .." là on part des carré , au lieu de revenir en arriere"
(31*31)% 30 = 1 ok index, il part cribler et sorte de liste Pi.suivant 37 (" re belotte ça va être avec 41 ce qui est simple à voir")
37*37 , (37*41% 30) = 1 ok index, ils partent cribler et sorte de liste Pi. suivant 47 qui va être avec 43 car fam 13...!
47*47 , (47 *53)% 30 = 1 ok index, il partent cribler et sorte de liste Pi. ...FIN on fait la somme des [1]

Conclusion: on a fait que 14 multiplications  sur 169 et calculé 8 index... , comme tu l'as fait remarquer à juste titre...
Mais surtout on commence toujours à cribler soit à partir du carré de a au minimum , ou plus loin , sans avoir à revenir...!

Ce que ne fait pas mon exécutable nBpremier win 32 car le jeune étudiant à l'époque ...il a fait au mieux mais très performant...

On va attraper la criblite....LoLLLL.

Passe une bonne fin de soirée Yoshi ...j'attends si tu veux, tes coordonnées par mail..Noël est proche....
@ +
gilbert

PS : As tu essayé le Gcrible retranscrit en c++...de Parisse B...?

yoshi
Hier 19:53:30

Que ça n'ait rien changé au problème, c'est normal, je n'ai fait que
- soulever un lièvre
- diminué de façon conséquente le nombre de produits (et autant de tests d'égalité) avant crible : si le nombre d'éléments de premiers est 13 (cas de n=3000), je supprime 78 multiplications, et donc 78 tests sur 169 soit 46 % de calculs inutiles et autant de tests puisque redondants.
  Si nn est le nombre d'éléments de la liste premiers, je supprime [tex]\dfrac{nn(nn-1)}{2}[/tex] calculs sur nn²...
  Mais pour n = 300 000 000, premiers contient 1987 nombres : je supprime donc 1 973 091 calculs sur 3 948 169 et autant de tests...
  Le % tend vers 50 % quand nn tend vers l'infini....

Je vais creuser cette histoire d'index qui sont calculés, validés mais que seul le dernier sert au crible...
Je ne comprends pas...
C'est TA traduction Python du script C++ ?

LEG
Hier 19:04:39

en définitive, ce sont certain départ de début d'index, qui ne sont pas marqué [0] car ensuite ça crible....pourquoi ???

peut être que c'était plus simple avec les pfam mais là je nage encore ...

LEG
Hier 18:49:50

Tu as entièrement raison à ce sujet...moi j'ai juste essayé de trouver pour calculer l'index si le produit j%30 == fam
mais je ne sais pas comment positionner les lignes...!

Je vais  copier et coller tes lignes...et tester.

Car effectivement je regarder et j'ai bien vu que le produit et son debut index n'était pas marquer [0] par exemple avec fam = 7 et n=4500

j = 7*31 = 217
217//30 = 7
et bien la 8eme cellule indice 7 était marquée [1], idem pour la cellule index 22 relatif à 23*29...

@+

RE ça n'a rien changé toujours les erreurs fam 1 et  7

== RESTART: E:\Documents\Conjecture de Goldbach\Crible_Eratosthène_Mod30.py == 91 , 121 , = 0,0
Donnez N: 4500
crible:[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0]
Nombre premiers criblés famille 1: 79 ----- 0.0
--- Temps total: 0.01 sec ---
>>>
== RESTART: E:\Documents\Conjecture de Goldbach\Crible_Eratosthène_Mod30.py == 187 , 217  = 0,0, 247 ok = 0
Donnez N: 4500
crible:[1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0]
Nombre premiers criblés famille 7: 84 ----- 0.01
--- Temps total: 0.01 sec ---
>>>

yoshi
Hier 17:54:31

Salut,

Je trouve ce morceau curieux :
    for a in (premiers):
        for b in (premiers):
            j = a * b
            if j%30 == fam:
                index = j // 30
        # On crible directement avec l'index
        for idx in range(index, lencrible, a):
            crible[idx] = 0

Pourquoi donc ?
Pour un a donné, on passe en revue tous les j=a*b et pour chaque b on teste si a*b%30==fam
Si oui, on passe index à j//30... et on continue les b jusqu'au prochain index.
Donc, au minimum pour tous les b, on a donc donc 1 valeurs de index, stockées nulle part ou traitées à la volée nulle part.
Ce n'est que lorsque pour un a donné, on a passé en revue tous les b possibles donc qu'on sort de la boucle for b qu'on crible avec l'index... Mais lequel ?
Avec cette indentation seulement le dernier calculé....
Après vérification pour n =3000
premiers=[7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53]
Nombre d'index correspondant pour chaque a :
1, 2, 1, 2, 2, 1, 2, 2, 1, 2, 1, 2, 1

D'autre part, si on a déjà testé le produit 7 * 13 (par exemple) pourquoi tester le produit 13*8 ? la réponse sera la même...
perte de temps !
On peut ainsi pour n =3000 passer à 91 tests au lieu de 169...
J'écrirais donc :

for i,a in enumerate(premiers):
    for b in premiers[i:]:
        j = a * b
        if j%30 == fam:
            index = j // 30

@+

[EDIT]
local variable 'index' referenced before assignment
veut simplement dire que lorsque tu fais for idx in range(index...
ta ligne ne sait pas ce que c'est que index, ni ce qu'il vaut :  before assignment = avant qu'une valeur lui ait été assignée (donnée)...

LEG
Hier 17:36:32

RE :
voici des exemple pour fam :1,7,11
== RESTART: E:\Documents\Conjecture de Goldbach\Crible_Eratosthène_Mod30.py ==
Donnez N: 300
crible:[1, 1, 1, 0, 0, 1, 1, 1, 1, 1]
Nombre premiers criblés famille 1: 8 ----- 0.0
--- Temps total: 0.01 sec ---
>>>
== RESTART: E:\Documents\Conjecture de Goldbach\Crible_Eratosthène_Mod30.py ==
Donnez N: 300
Traceback (most recent call last):
  File "E:\Documents\Conjecture de Goldbach\Crible_Eratosthène_Mod30.py", line 81, in <module>
    main()
  File "E:\Documents\Conjecture de Goldbach\Crible_Eratosthène_Mod30.py", line 76, in main
    GCrible(premiers, n, 7)
  File "E:\Documents\Conjecture de Goldbach\Crible_Eratosthène_Mod30.py", line 57, in GCrible
    for idx in range(index, lencrible, a):
UnboundLocalError: local variable 'index' referenced before assignment

>>>
== RESTART: E:\Documents\Conjecture de Goldbach\Crible_Eratosthène_Mod30.py ==
Donnez N: 300
Traceback (most recent call last):
  File "E:\Documents\Conjecture de Goldbach\Crible_Eratosthène_Mod30.py", line 81, in <module>
    main()
  File "E:\Documents\Conjecture de Goldbach\Crible_Eratosthène_Mod30.py", line 76, in main
    GCrible(premiers, n, 11)
  File "E:\Documents\Conjecture de Goldbach\Crible_Eratosthène_Mod30.py", line 57, in GCrible
    for idx in range(index, lencrible, a):
UnboundLocalError: local variable 'index' referenced before assignment

>>>

je prend n= 600; fam = 1
Donnez N: 600
crible:[1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1]
Nombre premiers criblés famille 1: 12 ----- 0.0



Donnez N: 1200
crible:[1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1]
Nombre premiers criblés famille 1: 22 ----- 0.01

Donnez N: 1800 : 121 est devenu premier...?
crible:[1, 1, 1,0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1], 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0]

pour n =2100 et fam = 1

Donnez N: 2100 ; 91 et 121 = 0,0 sont = 1,1..?
crible:[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0]
Nombre premiers criblés famille 1: 38 ----- 0.01

que veut dire : lencrible = len(crible) et ensuite il s'en sert  dans cette fonction :

 for idx in range(index, lencrible, a):
            crible[idx] = 0

on appelle à cribler ..?  pourquoi ne pas avoir mis aussi  lencrible[idx] = 0 ???

LEG
Hier 15:48:44

re :
Je pense peut être, qu'il saute des nombres premiers pi qui criblent et de ce fait cela augmente le nombre d'entier [1] qui ne sont pas marqué[0]

à cause de l'index qui serait mal mis...mais pourquoi dans ce cas, jusqu'à 600 le marquage des [1] en [0] est bon....???

LEG
Hier 14:49:50

moui mais pour moi c'est   ..... ????
ma version, c'est 3.7.64 bit de juin 2018

mon petit fils aucune idée, mais je pense que c'est 3.5 c'est ce que j'avais en décembre 2017...

voila ma version:
Python 3.7.1rc1 (v3.7.1rc1:2064bcf6ce, Sep 26 2018, 15:15:36) [MSC v.1914 64 bit (AMD64)] on win32

pour te donner un ordre d'idée le nombre de premiers de 7 à n par la fonction :
$ \frac {(n/2)} {Ln(n/2)} + \frac {(n/2)} {Ln(n)}$ = 392 ; pour  n = 3000 toujours < à $\pi(n) = 407$ fam.7

pour n = 3 000 000 000 ; fam 1

nbpremier donne :
>Le dernier nombre est:
2999999341
>trouvé à la position:
18 054 607

Gcrible donne : Nombre premiers criblés famille 1: 19 997 341 ----- 15.0
--- Temps total: 15.19 sec ---

si c'était du blé..il vaut mieux GCrible....LoLLL

yoshi
Hier 14:45:31

Bingo... Voilà ce que dit la doc officielle :

year = 2016
event = 'Referendum'
print(f'Results of the {year} {event}')
'Results of the 2016 Referendum'
LEG
Hier 14:42:07

Ca prend tournure...

Pour n = 30000
fam =7
total nombre premiers avec l'exécutable  nbpremier win32:
Allocation du Tableau en cours...
>Allocation Terminée!
>Calcul du tableau en cours...
>Calcul du tableau terminé!
>Le dernier nombre est:
29947
>trouvé à la position:
407

au lieu de
459
en 0,03..secondes , comme pour la fam 1  ???  problème .

nombre de premiers pour n = 30 000, par fam {1,7,11,.....29}
{403-1 ; 407; 406; 406; 411; 395; 408 et 407 }

yoshi
Hier 14:23:29

Salut,

Bon, je vais chercher à comprendre quand même...
Déjà, là :

    print("Nombre premiers criblés famille",fam,":", total," -----",int((time()-start_crible)*100)/100)


def main():
    # On demande N a l'utilisateur
    n = demander_N()

    # On récupère les premiers entre 7 et √2N
    premiers = eratostene(n)
    #lprint("premiers:", premiers)
    #print(f"nombres premiers entre 7 et {int((2*n)**0.5)}: {len(premiers)}")

    start_time = time()
    # On crible
    GCrible(premiers, n, 7)
    temps = time()-start_time
    print("--- Temps total:", int(temps*100)/100,"sec ---")

Plus l'index changé en idx, plus de message d'erreur pour 7 :

Donnez N: 30000
Nombre premiers criblés famille 7 : 459  ----- 0.0
--- Temps total: 0.03 sec ---


@+

[EDIT]
Quelle version de Python as-tu pour que le print (f...  marche chez toi ? >=6 ? et ton petit-fils ?
J'ai vu passer que depuis Python 3.6, l'affichage peut sez gérer avec des f-strings : je vais aller regarder ça de près : je suis toujours en 3.5 : ceci expliquerait peut-être cela ?

[EDIT2] Bingo... Voilà ce que dit la doc officielle :

year = 2016
event = 'Referendum'
print(f'Results of the {year} {event}')
'Results of the 2016 Referendum'
LEG
Hier 13:26:44

RE :
tu as raison pour ça:

  for idx in range(index, lencrible, a):
            crible[idx] = 0
 

pour le: print(f"Nombre premiers criblés famille {fam}: {total} ----- {int((time()-start_crible)*100)/100}")f
il m'avait dit que c'était pour calculer le temps des différentes fonctions le total....
Mais en plus chi... alors que c'était plus simple su tes programmes...!

Ensuite j'ai rien compris à ses {fam}: {total} que l'on peut virer....

En définitive pour imprimer il fait print une fois en haut....?  ouù ..?
et ça lui imprimait toute les fonctions
au lieu de le faire par étape...d'ailleurs je me suis em.... pour imprimer les index, les nombres ..etc , j'ai juste réussi à débloquer print Gcrible
pour éditer les [11111111111111111111]

C'est pour cela que je pense qu'il vaut mieux modifier à partir de ta version #v6. 2# c'est à dire cribleG3Y... mais je pense que l'on a pas besoin des pfam...de toutes les façons cela ne gène en rien pour la limite et rapidité car le GCrible ne va pas plus vite....alors qu'il n'utilise pas les pfam...

yoshi
Hier 12:32:18

Re,


Ça, c'est une horreur :

        for index in range(index, lencrible, a):
            crible[index] = 0

Je me demande pourquoi Python ne râle pas et comment il fait pour ne pas se paumer...
J'ai remplacé, parce qu'à mes yeux plus rationnel, par  :

        for idx in range(index, lencrible, a):
            crible[idx] = 0

Sauf s'il y a une raison profonde : index à la fois indice de boucle et indice de départ de boucle ???
Là, tu m'en bouches un coin :

 print(f"Nombre premiers criblés famille {fam}: {total} ----- {int((time()-start_crible)*100)/100}")

1. Qu'est-ce que ce f fiche là ? print(f...
    Je l'ai viré erreur de syntaxe. Une résurgence de printf( ?
2. Ou alors ce f a une raison d'être que j'ignore parce que, après ces modifs, je tombe sur ça :

Donnez N: 30000
Nombre premiers criblés famille {fam}: {total} ----- {int((time()-start_crible)*100)/100}
--- Temps total: {int(temps*100)/100} sec ---

Quel est le rôle de ces accolades entre guillemets ? "... {fam}...  {total}..."
Elles devraient afficher les valeurs de fam, total, etc... et il n'en est rien...

@+

LEG
Hier 11:31:10

re
voila ce que j'ai fais :
mais il y a erreur sur le résultat > 900..???


from itertools import product
from time import time
from os import system


def candidate_range(n):
    cur = 5
    incr = 2
    while cur < n+1:
        yield cur
        cur += incr
        incr ^= 6  # or incr = 6-incr, or however


def eratostene(n):
    n = int(n**0.5)
    prime_list = [2, 3]
    sieve_list = [True] * (n+1)
    for each_number in candidate_range(n):
        if sieve_list[each_number]:
            prime_list.append(each_number)
            for multiple in range(each_number*each_number, n+1, each_number):
                sieve_list[multiple] = False
    #print(prime_list[3:])
    return prime_list[3:]


def demander_N():
    n = input("Donnez N: ")
    n = int(n.strip().replace(" ", ""))
    #n = int(30 * round(float(n)/30))
    #print(f"On prend N = {n}  (30 * {int(n/30)})")
    return n


def lprint(text="", liste=None):
    if len(liste) < 100:
        print(text + str(liste))


def GCrible(premiers, n, fam):
    start_crible = time()
 
    # On génère un tableau de N/30 cases rempli de 1
    crible = n//30*[1]
    lencrible = len(crible)

    # On calcule les restes: ri = 2*n/pi
    nbpremiers = len(premiers)
 
    for a in (premiers):
        for b in (premiers):
            j = a * b
            if j%30 == fam:
                index = j // 30
        # On crible directement à partir de l'index
        for idx in range(index, lencrible, a):
            crible[idx] = 0

    total = sum(crible)
    lprint("crible:", crible)
    print(f"Nombre premiers criblés famille {fam}: {total} ----- {int((time()-start_crible)*100)/100}")


def main():
    # On demande N a l'utilisateur
    n = demander_N()

    # On récupère les premiers entre 7 et √2N
    premiers = eratostene(n)
    #lprint("premiers:", premiers)
    #print(f"nombres premiers entre 7 et {int((2*n)**0.5)}: {len(premiers)}")

    start_time = time()
    # On crible
    GCrible(premiers, n, 1)
    temps = time()-start_time
    print(f"--- Temps total: {int(temps*100)/100} sec ---")


main()
system("pause")
 

résultat :

=== RESTART: E:\Documents\Conjecture de Goldbach\Crible_G.T.Y_modulo30.py ===
Donnez N: 300
crible:[1, 1, 1, 0, 0, 1, 1, 1, 1, 1]
Nombre premiers criblés famille 1: 8 ----- 0.0
--- Temps total: 0.01 sec ---
>>>
=== RESTART: E:\Documents\Conjecture de Goldbach\Crible_G.T.Y_modulo30.py ===
Donnez N: 600
crible:[1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1]
Nombre premiers criblés famille 1: 12 ----- 0.0
--- Temps total: 0.01 sec ---
>>>
=== RESTART: E:\Documents\Conjecture de Goldbach\Crible_G.T.Y_modulo30.py ===
Donnez N: 900
crible:[1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0]
Nombre premiers criblés famille 1: 18 ----- 0.01
--- Temps total: 0.01 sec ---
>>>
=== RESTART: E:\Documents\Conjecture de Goldbach\Crible_G.T.Y_modulo30.py ===
Donnez N: 30000
Nombre premiers criblés famille 1: 465 ----- 0.0 ..FAUX
--- Temps total: 0.01 sec ---

Ensuite si je change le paramètre de la fam et que je met 7 au lieu de 1
à la ligne GCrible


GCrible(premiers, n, 1)

voici l'erreur:

Traceback (most recent call last):
  File "E:\Documents\Conjecture de Goldbach\Crible_G.T.Y_modulo30.py", line 81, in <module>
    main()
  File "E:\Documents\Conjecture de Goldbach\Crible_G.T.Y_modulo30.py", line 76, in main
    GCrible(premiers, n, 7)
  File "E:\Documents\Conjecture de Goldbach\Crible_G.T.Y_modulo30.py", line 57, in GCrible
    for index in range(index, lencrible, a):
UnboundLocalError: local variable 'index' referenced before assignment

Pied de page des forums