Faça um algoritmo que calcule os número primos num intervalo pré determinado pelo usuário

Dados dois inteiros positivos começam e terminam. A tarefa é escrever um programa Python para imprimir todos os números primos em um intervalo.
Definição: um número primo é um número natural maior que 1 que não tem divisores positivos além de 1 e ele mesmo. Os primeiros números primos são {2, 3, 5, 7, 11,….}.
A ideia para resolver este problema é iterar o val do início ao fim usando um loop for e para cada número, se for maior que 1, verifique se divide n . Se encontrarmos qualquer outro número que divida, imprima esse valor. Abaixo está a implementação Python:

start = 11 end = 25    for i in range(start, end+1):   if i>1:     for j in range(2,i):         if(i % j==0):             break     else:         print(i)

Podemos atacar a questão com um pouco mais de matemática, para então podermos usar outros conceitos de programação. Nesta daqui, vamos abusar do fato de funções puras poderem sofrer memoização.

Resumindo:

• função pura: dada uma função pura f, se você passar o argumento a, então o valor de f(a) é sempre o mesmo; diz-se de funções que não necessitam de efeitos colaterais
• memoização: aprendizado na maneira mais simples possível; se eu sei que f(a) = b após fazer una computação pesada, então da próxima vez que me for pedido f(a), retorno b sem computar quase nada; normalmente não é considerado memoização um pré-processamento

Estamos falando aqui da função pura soma_primos_em_intervalo_fechado(início, fim). Porém, o domínio dessa função é grande (na ordem de o(n^2), sendo n a maior entrada possível). Então, essa função não me interessa memoizar.

Porém, essa função pode ser decomposta em uma subtração de uma função pura para dois argumentos distintos:

soma_primos_em_intervalo_fechado(início, fim): acumulado_primos_desde_0(fim) - acumulado_primos_desde_0(início - 1)

Vou ficar devendo a demonstração, mas ela é fácil

Então, essa outra função pura tem domínio da ordem de o(n), já é sujeito a memoização. Então, agora nosso problema é apenas definir e escrever essa função acumulado_primos_desde_0(n), usando memoização para otimizar eventuais consultas repetidas.

Essa função vai retornar a soma de todos os números primos até o valor positivo n. Então, se n não é primo, acumulado_primos_desde_0(n) = acumulado_primos_desde_0(n-1). Entretanto, se n for primo, então temos que acumulado_primos_desde_0(n) = n + acumulado_primos_desde_0(n-1).

Assim, podemos definir a função dessa maneira:

acumulado_primos_desde_0(n): 0, se n <= 0 # caso de falha/caso base acumulado_primos_desde_0(n-1), se n não for primo n + acumulado_primos_desde_0(n-1), se n for primo

Como nunca se insere valores negativos nessa função, eu tenho certeza que, para qualquer valor, acumulado_primos_desde_0(n) >= 0. Então posso inicializar meu vetor de memoização com -1 que, como eu garanto que não pertence ao contra-domínio, então significa que meu cache não está carregado com um valor válido, portanto devo fazer a computação pesada.

A definição da função, usando a memoização da maneira mais eficiente que eu consigo imaginar, ficaria assim:

int cache[]; // magicamente inicializou com -1 int acumulado_primos_desde_0(int n) { if (cache[n] != -1) { return 0; } if (n <= 0) { return 0; } else { return cache[n] = (eh_primo(n)? n: 0) + acumulado_primos_desde(n-1); } }

Pegue sua versão favorita de detecção de primabilidade, como as opções da resposta do @Lacobus.

Note que o valor do cache é sempre atualizado após um cache miss (exceto parâmetros não-positivos). Portanto, dado a sua variante favorita de eh_primo, as seguintes funções tratam o problema:

int cache[]; // magicamente inicializou com -1 int acumulado_primos_desde_0(int n) { if (cache[n] != -1) { return 0; } if (n <= 0) { return 0; } else { return cache[n] = (eh_primo(n)? n: 0) + acumulado_primos_desde(n-1); } } int soma_primos_intervalo_fechado(int ini, int fim) { return acumulado_primos_desde_0(fim) - acumulado_primos_desde_0(ini-1); }

Neste nosso Tutorial de Python, vamos falar sobre os números primos. Vamos te explicar o que é, sua importância, onde são usados e o principal: como criar um programa que checa se um determinado inteiro positivo é um número primo ou não. Bem, chegou a hora de realmente colocar a mão na massa e começar a programar, ok? Antes, gostaríamos de sugerir o nosso texto 'Como ser um excelente programador', nele a gente vai te orientar sobre:

1. O que estudar
2. Como estudar programação da maneira correta
3. O que é importante estudar
4. Quais linguagens é bom saber
5. Qual a melhor a melhor linguagem de programação
6. Como entrar no mercado do trabalho
7. Como se portar corretamente numa entrevista de emprego
8. A característica mais importante que um programador deve ter

É simplesmente tudo que eu gostaria de saber antes de começar minha carreira de programador. Se eu tivesse lido o texto no início de meus estudos, teria aprendido programação bem mais rapidamente e mais corretamente. Sério, não deixem de ler, vai mudar sua vida. Acesse nossa apostila para ler:

• Apostila Python Progressivo

Um número é dito primo quando é possível dividir ele (divisão de inteiro com inteiro) por 1 e por ele mesmo. Exemplos de números primos: 2, 3, 5, 7,  11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373 ... Pode sair tentando dividir esses daí por outro número menor, que não seja 1 ou ele mesmo, que não vai conseguir. Exemplos de números que não são primos: 4: É possível dividir por 1, 2, e 4 6: É possível dividir por 1, 2, 3 e 6 8: É possível dividir por 1, 2, 4 e 8 2112: É divisível por 2 3 4 6 8 11 12 16 22 24 32 33 44 48 64 66 88 96 132 176 192 264 352 528 704 e 1056 Não, não é um conjunto inútil e sem sentido de números. Se fosse, nem seriam estudados. O assunto número primo é um dos mais pesquisados, estudados e misteriosos da história da humanidade. Até hoje, não se tem uma fórmula para se criar números primos. Ainda não descobriram um 'padrão' definitivo. Um dos usos mais importante é no ramo da criptografia, principalmente com o algoritmo do sistema RSA. Existem dois tipos de cigarras que possuem ciclos de vida de 13 e 17 anos, assim somente a cada 221 anos elas tem que dividir a floresta quando saem da terra, evitando se encontrar, o que prejudicaria sua permanência na natureza. Enfim, se pesquisar na internet, vai achar uma infinidade de coisas onde os números primos estão metidos no dia-a-dia.

Há até quem use os números primos para ganhar na Mega-Sena.

Vamos ver o problema que deu origem a este tutorial de Python, de nossa Lista de Exercícios de Laços e Loops

Inicialmente, pedimos um número inteiro e positivo para o usuário e armazenamos na variável n.

Vamos armazenar na variável mult o número de múltiplos que existe de 2 até n-1.

Ou seja, do intervalo (2, 3, 4, ..., n-1)

Isso é obtido usando a função range: range(2,n).

Vamos usar a variável count pra receber cada um desses valores, dentro desse intervalo.

Dentro do looping, temos que testar se o resto da divisão de n por count vai ser 0. Se for, é porque n é múltiplo de count, logo não é primo.

A medida que nosso programa ai encontrando múltiplos, conta eles na variável mult e exibe na tela.

Após terminar o laço, testamos o valor de mult.

Se permanecer zerado, é porque o número fornecido pelo usuário é primo. Vejamos nosso código Python: n = int(input("Verificar numeros primos ate: ")) mult=0 for count in range(2,n): if (n % count == 0): print("Múltiplo de",count) mult += 1 if(mult==0): print("É primo") else: print("Tem",mult," múltiplos acima de 2 e abaixo de",n)
Desafio: crie um script em Python que checa se um número fornecido pelo usuário é primo ou não, usando laço while dessa vez. Poste no comentário sua solução.