# include & ltmath.h & gt# include & ltstdio.h & gt# include & ltmemory.h & gt# include & lttime.h & gt#define ST 7 #¿Definir movimiento? 4 #¿Definir TAMAÑO DE BLOQUE? (510510 * 8)//2 * 3 * 5 * 7 * 11 * 13 * 17 = 510510 #Definir MAXM? ((BLOCKSIZE & gt& gtMOVE)+1)#Definir SET_BIT(a, n)? a[n>>3]|=(1<<(n&7))typedef unsigned int uinttypedef unsigned short ushort typedef unsigned char uchartypedef unsigned long long uint64 static ushort numbit 0[1< ; base TPL[MAXM * 2]; static int sieve(){ int primos = 1; const uint maxp = (1 < <16) + 1000;? for(uint p = 3; p & ltmaxpp+= 2){ if(0 = =(base TPL[p >> move]&(1<<(p/2&7) ))) { ?Número primo[ número primo++]= p;? for(uint I = p * p/2;i<maxp/2;i += p) SET_BIT(BaseTpl,I);? } }Devuelve número primo; } static void initBit( ){ memset(BaseTpl, 0, sizeof(base TPL)); for(int k = 1; k & ltST; k++) for (int p = Prime[k]/2 ; p & ltsizeof(base TPL)* 8; p += Prime[k])? SET_BIT(BaseTpl,p);for(int I = 1;i<sizeof(numbit 0)/sizeof(numbit 0[0]);i++)numbit 0[I]=numbit 0[I>>1]+ (I & amp. 1); para (int j = 0; j & ltsizeof(numbit 0)/sizeof(numbit 0[0]); j++)? numbit 0[j] = 16-numbit 0[j]; } static void inlinechrssoutfactormod 6(uchar bitarray[], const uint start, ? const uint leng, uint factor){ uint s2, s 1 = factor-start % factor; s1 + = factor - factor * (s 1% 2); if (inicio & lt; = factor) s1 = factor * factor; const char skip[] = {0, 2, 1, 1, 0, 1}; char mrid =((inicio+s 1)/factor)% 6-1;? s 1 = s 1/2+saltar[mrid]* factor;? S2 = s 1+skip[mrid+1]* factor para (factor += 2 * factor; s2 & lt=cold/2;){ SET_BIT(matriz de bits, s1 += factor; 1 SET_BIT(matriz de bits, S2); s2 += factor; //6k+5 } si (s 1 & lt; = l
eng / 2) SET_BIT(bitarray, s 1); } static int inline setSieveTpl(uchar bitarray[], uint start, int leng) { const int offset = start % tamaño de bloque; gt move), (cold & gt& gtMOVE) + 2 if (start & lt; 32) ?*((short *)bitarray)= 0x 3491; //0x 0011 0100 1001 0001 bitarray[0]| <<(desplazamiento % 16/2))-1;leng+= desplazamiento % 16;? *((uint *)bitarray+(leng>>6))| = ~((1u<<(Leng/2&31))-1);? Desplazamiento de retorno % 16; } static uint 64 segmented sieve(uint start, int leng) { uchar bitarray[MAXM+64]; const int offset = setSieveTpl(bitarray, inicio, longitud); inicio -= desplazamiento, longitud += const int maxp = (int)sqrt((doble)inicio+long)+1;? for (int i = ST, p = Prime[I]; p & ltmaxpp = Prime[++ I]) crossoutfactormod 6(bitarray, start, length, p) uint 64 sum = 0; i<Leng/2;i++){? if(!(bitarray[I>>3]&(1<<(i&7))))) #si 0? printf("%u\n ",inicio + i * 2 + 1), suma++; # else suma+= inicio+I * 2+1; }suma de retorno}int sievePrimes(uint start, uint stop){? uint64 primo = 0;? if(start<= 2&&stop>=2) {prime=2;printf("%d\n",2);} const int segsize=31<<14;? si(inicio+tamañoseg>detener)? devolver números primos+tamiz segmentado(inicio, parada-inicio+1);? primos += tamiz segmentado (inicio, tamaño seg - inicio % tamaño seg); for (uint I = inicio/tamaño seg+1; i & ltstop/tamaño seg; i++) primos += tamiz segmentado (i * tamaño seg, tamaño seg);? primos+= tamiz segmentado(stop-stop % segsize, stop % segsize+1); uint inicio = 0, parada = 10000000; tamiz(); bit de inicio();? const char * out = "PI(% u, %u) = %lld, tiempo u
se % u ms \ n " while (scanf("%u %u ",&start&stop)== 2&start<stop){ clock_t t start = clock()? int primeCnt = sievePrimes(inicio, parada);? printf(salida, inicio, stop, primeCnt, clock()-t start);? }Return 0 }//PI[1, 2147483647] = 105097565, tiempo utilizado 159
65.438+0 mil millones equivale a 2 elevado al 32. Según el teorema de los números primos, es aproximadamente un millón. Las máquinas actuales no sirven para nada con el método de detección de campos numéricos. Hay un sitio web que está cansado de hacerlo. /prime.utm.edu/list, que calcula principalmente los primeros 5 millones de números primos. Por lo tanto, el algoritmo más rápido es crear un rastreador y capturar estos números primos. En cuanto al algoritmo rápido para la suma, parece que no es necesario. bits. Mi algoritmo rápido está diseñado.