O que são números primos e por que eles importam
Número primo é um inteiro maior que 1 que só é divisível por 1 e por ele mesmo. Isso é a definição, mas o que ela não diz é que existem infinitos primos e que eles se tornam cada vez mais raros conforme o número sobe. Em média, a distância entre dois primos consecutivos perto de N cresce com log(N). Não é linear. Não há fórmula fechada que gere o próximo primo garantidamente.
Gerando uma lista de numeros primos
A forma prática de construir uma lista de numeros primos até um limite N é usar o Crivo de Eratóstenes. Ele remove múltiplos a partir de cada primo encontrado. A complexidade é O(N log log N), o que significa que para N = 10 milhões, roda em frações de segundo na maioria das máquinas modernas.
def crivo_eratostenes(limite):
if limite 2:
return []
marcatdo = [True] * (limite + 1)
marcatdo[0] = marcatdo[1] = False
for i em range(2, int(limite0.5) + 1):
se marcatdo[i]:
para j em range(i*i, limite + 1, i):
marcatdo[j] = False
retornar [i para i, primo em enumere(marcado) se primo]Isso retorna uma lista real. A saída para limite=30 é [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]. Simples. Eu já passei dor de cabeça com essa implementação quando precisava gerar uma lista de primos para criptografia em ambiente embarcado com memória extremamente limitada. O Crivo clássico aloca um array booleano inteiro e transbordava em dispositivos com poucos megabytes. A solução foi trocar para um crivo segmentado, onde você trabalha em blocos de tamanho fixo — digamos, 32768 números por vez — e cruza apenas os blocos necessários. Isso reduziu o consumo de memória de cerca de 12 MB para menos de 200 KB no caso específico. Funciona bem, mas exige cuidado com os índices de borda entre segmentos. Um erro de contagem aí e você introduz um falso primo silenciosamente.
Pitfalls comuns e nuances que poucos ensinam
Primeiro equívoco frequente: 1 não é primo. Já vi gente incluir 1 em listas geradas automaticamente porque a definição ingênua de "só divisível por 1 e por ele mesmo" parece se aplicar. Não se aplica. Por definição formal, primos começam em 2. Segundo: Crivo de Eratóstenes não é a melhor ferramenta para tudo. Se você só precisa testar primalidade de números esparsos grandes, gerações sob demanda ou testes de primalidade probabilísticos (Miller-Rabin) são mais eficientes. O crivo é ótimo quando o interesse é obter todos os primos até um limite conhecido. Fora disso, o custo fixo de alocação e preenchimento não compensa.
Um detalhe que passa despercebido: números primos gêmeos — pares como (3,5), (11,13), (17,19) — são infinitos? Ninguém sabe. É um problema em aberto. Então não confie em heurísticas que assumam regularidade entre eles. Os gaps variam de forma imprevisível. Ao gerar listas muito grandes, o formato de arquivo importa. Uma lista de primos até 10 milhões em texto puro ocupa cerca de 78 MB. Em binário compactado, cabe em 1/5 disso. Se a aplicação precisa ler rapidamente em disco, considere salvar em formato estruturado (por exemplo, arrays numpy packing) em vez de CSV ou texto simples.
👉 Clique no botão abaixo para saber mais sobre o assunto!
Alternativas e quando usar cada uma
Para limites pequenos até ~100 milhões, o Crivo clássico em Python com otimizações (ignorar pares, usar bytearray) costuma ser suficiente. Para limites maiores que 10^9, o crivo segmentado ou bibliotecas especializadas como GMP com funções de contagem de primos ((x)) são a opção realista. Se o objetivo é apenas verificar se um número específico é primo, use Miller-Rabin com bases determinísticas para o range desejado. Para N
3.317.044.064.279.887, as bases [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37] são suficientes e determinísticas. Sem aleatoriedade, sem falsa confiança.
O ponto fraco do crivo é a necessidade de memória linear em N. Se N = 10^10, você precisa de dezenas de gigabytes. Não adianta insistir. Nesse regime, mude para geradores sob demanda ou teste de primalidade sob demanda.
Lista de numeros primos — dados práticos
A tabela a seguir resume tamanhos aproximados e tempos de execução em uma máquina típica (CPU moderna, Python otimizado, crivo com bytearray): N = 10^6: ~78 mil primos, ~0,04 segundos, ~1 MB em disco.
N = 10^8: ~5,76 milhões de primos, ~2,5 segundos, ~80 MB em disco. N = 10^9: ~50,8 milhões de primos, ~25 segundos com crivo segmentado, ~400 MB em disco.
Os tempos variam conforme a linguagem e as otimizações. Em C++, tudo acima cai pela metade ou mais. Em Rust, com SIMD, melhora ainda mais. A escalabilidade é linear no worst case, mas o fator constante importa muito. Se você precisa de uma lista pronta para baixar, a opção mais confiável é gerar localmente com o algoritmo acima. Listas pré-computadas da internet podem estar desatualizadas, incompletas ou conter erros de digitação. Gerar localmente leva segundos para a maioria dos casos práticos e garante integridade.
