for (int i = 5; i*i <= n ; i = i + 4) {
        int salto = 2 * i;
        int salto2 = 4 * i;
        if (P6 == 1) {
            for (int j = i * i; j <= n; j += salto2) {
                if (j < n) {
                    P6[j] = 0;
                }
                j += salto;
                if (j < n) {
                    P6[j] = 0;
                }
            }
        }
        i += 2;
        if (P6 == 1) {
            for (int j = i * i; j <= n; j += salto) {
                if (j < n) {
                    P6[j] = 0;
                }
                j += salto2;
                if (j < n) {
                    P6[j] = 0;
                }
            }
        }
    }
 
 for (long long i = 0;i<cantidad; i++) {
            long long mult = ultimo * ultimo % Secuencia;
            if (mult % 2 == 1) {
                mult += Secuencia;
            }
            array.mult = mult;
       
        }
for (j = 0; j < cantidad; j++) {
                if (array[j].mult == 0) {                   
                    array[j].vacio = 1;
                } else { // si el minimo es 0 incremento el contador de vacios
                    long long pos;
                    long long primo;
                    long long mult;
                    mult = array[j].mult;
                    pos = array[j].pos;
                    while(mult < limite-Secuencia[pos]*Secuencia[pos])
                    {
                    do {
                        primo = limite - mult; // calculo  no primo
                        mult += Secuencia[pos] * 2;
                    } while (Primos[primo] == 0); // calculo el siguiente multiplo
                    Primos[primo] = 0; //guardo en memoria
                                       }
                                   }
                   }
 
Los fragmentos de código representan dos métodos para el cálculo de números primos. Uno es una versión optimizada de la criba de Eratóstenes, conocida como la criba de patrones optimizada, con un costo aproximado n/ log log n . El otro método es lo que llamo la criba inversa, que también puede ser optimizada y tiene un costo teórico similar de n/ log log n
Ambos métodos difieren en su dirección de exploración: uno es ascendente y el otro descendente. La dimensión del problema para ambos métodos es desde el inicio de los cálculos de primos hasta el punto final.
Suponiendo que no hay errores, calcular los primos con la criba de Eratóstenes hasta n/2 tiene un costo teórico de (n/2 log log n/2). De manera similar, la criba inversa calcula desde n hasta n/2  con un costo aproximado equivalente.
Al ejecutar secuencialmente ambos métodos para obtener los primos desde 0 hasta n, los tamaños de los problemas son n/2 . Por lo tanto, el costo total sería:
(n/2 log log n/2)+ (n/2 log log n/2)+n+…
erastotenes      inversa      juntar datos
donde "Eratóstenes" representa el método de la criba ascendente optimizado, "inversa" denota la criba descendente optimizada, y "juntar datos" se refiere al proceso de combinar los resultados obtenidos.
En resumen, los costos aproximados de los métodos son los siguientes:
•   Criba de Eratóstenes sin optimizar: n log log n
•   Criba de Eratóstenes optimizada: n/log log n
•   Criba inversa optimizada: n/log log n
•   Método híbrido (aproximadamente): 2*(n/2 log log n/2)
Estos métodos ofrecen diferentes enfoques para calcular números primos en el rango especificado, cada uno con sus respectivos beneficios y optimizaciones aplicadas.
 
Ahorro teorico.
plot (n/2/ ( log log (n/2)))*2-n/log log n de 0 a1000000 - Wolfram|Alpha (wolframalpha.com)














Cantidad de iteraciones menos cantidad de primos
plot -(n/ln(n))+(n/2/ ( log log (n/2)))*2 de 0 a1000000 - Wolfram|Alpha (wolframalpha.com)

 
Método Híbrido con Divide y Vencerás Refinado
1.   División del rango inicial:
o   Inicialmente, dividimos el rango de búsqueda de primos, que va desde 0 hasta n, en dos partes iguales: una desde 0 hasta n/2 y otra desde n/2 hasta n.
2.   División hasta tamaño óptimo:
o   Aplicamos el principio de divide y vencerás nuevamente sobre cada mitad del rango hasta que el tamaño del problema sea óptimo para aplicar la criba de Eratóstenes ascendente y descendente.
3.   Cálculo de costos por segmento:
o   Para cada división, calculamos el costo de aplicar la criba de Eratóstenes optimizada y la criba inversa en cada segmento resultante.
4.   Suma de costos:
o   Sumamos los costos de cada segmento resultante, considerando la segmentación repetida y la aplicación de los métodos ascendente y descendente según sea necesario.
Ejemplo de cálculo:
Supongamos que dividimos el rango inicial de 0 a n hasta que cada segmento tenga un tamaño que sea óptimo para aplicar la criba de Eratóstenes optimizada y la criba inversa. Sea k el número de divisiones necesarias hasta alcanzar el tamaño óptimo.
•   Costo por cada división hasta tamaño óptimo: O(n/2^k log log (n/2^k)), donde k es el número de la división.
•   Finalmente, sumamos los costos de todos los segmentos resultantes:
Costo total≈k⋅O(n/2^k log log (n/2^k)
Iterpretación:
•   Eficiencia: Este método aprovecha al máximo el principio de divide y vencerás al segmentar repetidamente el rango de búsqueda hasta alcanzar tamaños de problema óptimos para aplicar los métodos ascendente y descendente de manera eficiente.
•   Optimización: Cada división reduce significativamente el número de operaciones necesarias, optimizando el tiempo de ejecución total para la búsqueda de números primos en grandes intervalos.
•   Implementación: La implementación práctica requerirá una gestión cuidadosa de la segmentación y la combinación de resultados para asegurar la correcta identificación de todos los números primos hasta n.
Este enfoque refinado del método híbrido con divide y vencerás es especialmente útil cuando se requiere maximizar la eficiencia en la obtención de primos en grandes intervalos, minimizando el tiempo de cálculo necesario mediante una estrategia de segmentación repetida y aplicación de métodos optimizados para cada segmento resultante.