Olá e bem-vindo.
Eu gostaria de fornecer um demonstração de
uma solução para o nosso desafio anterior que era escrever um programa
que gerasse números primos.
E então, novamente, todo o ponto deste programa era usar uma
matriz, você deseja aprender todos sobre matrizes e faça isso.
Então tentei descrever o algoritmo de número primo antes.
Mas, para apenas mencioná-lo novamente, você pode verificar se um primo
é ou não um número primo.
O número primo significa que uh não é divisível uniformemente
por qualquer outro número primo.
Então esse é o algoritmo de noção que vamos passar.
E é por isso que é um número primo é porque qualquer inteiro não primo
pode ser expresso como um múltiplo de fatores primos.
Então, por exemplo, 20 tem o fatores primos 2 2 e 5.
Então, sabendo disso, isso diz a você que os números primos não são igualmente divisíveis
por nenhum outro número primo.
Então, isso pode ajudar a fazer uma teste de número primo eficiente.
Então o que você pode fazer é você pode verificar
os números primos gerados anteriormente.
Assim, podemos armazenar nosso gerou números
primos em uma matriz, e é assim que nós pode encontrar esta informação.
Além disso, qualquer 9 inteiro primo n deve tem como um de seus fatores um número
inteiro menor ou igual à raiz quadrada de n.
Então, isso significa que só é necessário para determinar se um determinado
número inteiro é primo testando-o para pares divisibilidade contra todos os fatores primos até
a raiz quadrada do inteiro.
Então você pode parar aí e novamente, torna-o mais eficiente.
Isso vai ser perceptível no meu loop interno quando eu salto
para determinar se eu não encontrou um número primo.
Eu vou pular se eu conseguir a raiz quadrada do inteiro, é uma
condição de saída essencialmente.
Então, vamos seguir e o caminho que você pode
verificar é que você acabou de dizer p dividido por números primos é maior do que o sub-I primo, e usaremos isso
no loop mais interno para teste se o valor de p excede ou não
a raiz quadrada do I.
Então, vamos prosseguir e apresentar o código blocos para começar a escrever algum código.
Vamos fazer o básico aqui, crie um projeto.
Chamaremos nosso projeto de primos.
Então, vamos para
um novo projeto e vamos para o aplicativo de console.
E vamos chamá-lo de primos.
Diga a seguir, nós não vamos para usar este compilador.
Eu estava brincando com compiladores, quero ter certeza de que
tenho o compilador certo. apenas use o compilador cygwin.
Então está gerando meu principal arquivo de origem e está vazio.
Vamos nos livrar do printf e comece a escrever algum código.
Vamos incluir um arquivo chamado touro padrão.
Eu não fiz isso ainda; Eu estive criando meus booleanos como sublinhados.
Vamos apenas fazer um pequeno teste, Eu quero ser capaz de fazer bool.
Agora podemos usar bools.
Normalmente em C89, o tipo de dados para verdadeiro ou falso é sublinhado bool.
Mas você pode realmente ter um tipo definição em versões posteriores e no arquivo bool
padrão para apenas use bools e também permite que você
use true false como valores.
Então, temos que criar alguns variáveis aqui primeiro.
Vamos criar nosso contador que vamos chamar de p.
Esse vai ser o nosso contador para o nosso loop
de quando verificamos de p a 100 números.
Esse será o nosso loop externo.
Também vamos criar um variável para nosso contador de loop interno.
É aqui que verificamos nossos primos anteriores.
Na verdade, não vamos inicializá-lo aqui vamos inicializá-lo no loop.
Vamos criar nosso array que será um número inteiro de números
primos e terá o tamanho 50.
E não vamos inicializar para qualquer coisa, menos 0 por enquanto.
E então vamos criar um índice primo, e isso nos
ajudará a pular todos os nossos números pares, e vamos apenas definir isso para 2.
Esta variável está realmente indo para ter certeza
de que começamos com o índice correto, porque vamos para codificar os primeiros 2 números.
Isso é o que vamos fazer primeiro.
Estamos indo para o código rígido nossos primeiros 2 números primos.
Então é assim que podemos acessar o array.
Nós sabemos como criar um array em linha 10, você apenas especifica o tipo
de dados seguido pelo nome e, em seguida, no colchetes especificamos o tamanho.
E então estamos inicializando tudo para 0, esta é uma
característica C99 que podemos fazer.
E para atribuir dados a uma matriz, Posso apenas dizer o nome da matriz e, em
seguida, o valor do índice.
Lembre-se de que as matrizes são baseadas em 0.
Então, vou dizer primo sub-0.
E o primeiro primo será 2.
2 é o primeiro número primo.
O segundo número primo é vai ser igual a 3.
Assim eu tenho alguns primos números
que posso testar anteriormente para encontrar números primos adicionais.
E agora vem o nosso looping.
Vamos precisar de exterior para loop que passa por todos os
números de 5 a 100.
Sabemos que 4 não é um número primo então, estou apenas começando com 5.
Portanto, podemos dizer que 4 p é igual a 5, p é menor ou igual a 100 e então vamos
pular os números pares.
Então, vamos dizer p é igual a p mais 2.
Não precisamos olhar em nenhum número, esse será o nosso loop externo.
E, novamente, você deveria ser testando enquanto você está indo.
Agora também vamos definir uma variável booleana que nos dirá se ou
não encontramos um número primo.
Então é aqui que posso usar bool, e vou apenas
criar uma variável local Boolean is prime.
Eu vou ter isso inicializado dizer é verdade porque só vou definir como falso se
eu tiver percorreu toda a lista de números primos
gerados anteriormente ou Eu tenho o último primo e certifique-se de que não é a
raiz quadrada.
Então, o primo vai ser igual a verdadeiro para cada
iteração de 5 a 100, ignorando 2.
Agora meu loop interno vai através de todos os nossos números primos
que geramos anteriormente.
Faça com que não tenhamos ido melhor do que a raiz quadrada do I.
Então, vamos examinar todos os os números até chegarmos à raiz quadrada, que pode ser
nossa condição x.
Também vamos sair se encontrarmos um número primo.
Então, vamos dizer se é primo é verdade e
ultrapassamos nosso limite, que será p dividido por primos sub-I é maior ou
igual a primos sub-I.
E então vamos mais mais mais I é nossa variável de controle de loop.
Este é realmente o chave para o algoritmo.
Então, vamos tentar encontre todos os nossos
primos de 5 a 100 pulando os números pares.
E então, em nosso loop interno, estamos vamos começar
em 1, vamos percorrer todo o caminho até definirmos é de primo a verdadeiro ou alcançamos nossa condição de saída, que
é a o número p dividido pelo primo sub-I é maior do que o primo sub-I,
e isso é essencialmente terminando em fazer nosso quando encontramos uma raiz quadrada, porque
isso é outra condição do algoritmo.
Se esse é o nosso loop, dentro do nosso loop,
vamos verificar se há primos.
A maneira como um número é primo é você dividir pelo número.
E se você não tem um 0, então você está pronto para ir.
Então você pode apenas fazer um mod p primo sub-I é igual a 0.
E se isso for verdade, então você
não tem um número primo.
Então você pode definir o Booleano igual a falso.
E então é isso que fazemos para todo o loop, porque tudo o
que estamos fazendo é para definir o booleano como falso.
E isso vai nos dizer que não encontre um número primo, portanto, não queremos
adicionar p ao nosso array de primos.
Ok, então a última coisa a fazer é apenas verifique se o booleano foi definido como verdadeiro,
se foi definido como verdadeiro, então queremos preencher nosso array.
Queremos adicioná-lo ao array. Então onde adicionando às matrizes encontramos o primo.
Então, nós apenas dizemos primos e então dizemos índice primário.
Porque, lembre-se, este é o único que é realmente representado pelo índice
para onde queremos colocar a matriz, que queremos começar no elemento 3, que é
o índice 2.
Então, queremos ter certeza de que vamos colocá-lo o ponto certo na matriz, e
apenas o definimos como p porque p era o número primo que descobrimos porque lembre-se de que este é o loop for externo.
Estamos tentando verificar se esse é um número primo.
Começamos às 5.
Dizemos que se 5 vai ser primo, se podemos ir para esses números começando em 1 e, em seguida,
comparar com qualquer primos anteriores e se não for divisível por 0, então
estamos bem e temos que fazer isso para tudo.
E então a última coisa que nós o que queremos fazer
é apenas aumentar esse índice primo.
Então, da próxima vez que encontrarmos um primo número, estamos no índice certo.
E é isso.
E este é o todo algoritmo para encontrar números primos.
Então você quer salvar isso e construir isso, certifique-se de que tudo está pronto para ir.
Foram bons.
Então eu gosto de adicionar o verdadeiro falso valores incluindo bool padrão,
não se esqueça disso.
E então a última coisa que nós temos que fazer é apenas
imprimir os números primos.
Portanto, podemos apenas ter um loop for simples.
E vamos imprimi-los todos na mesma linha, então não vamos adicionar
um feed de linha.
Então o que vamos fazer é vamos reinstanciar nossa
variável de controle de loop para 0 I.
Nós vamos percorrer todo o caminho até o nosso índice principal, que será
o tamanho de tudo na matriz e apenas imprimi-lo em uma única
linha, por cento I ou d e sub-I principal.
E então, no final, vamos adicionar um feed de linha.
Algo assim com ponto e vírgula.
Mas, novamente, coisas para aviso neste programa.
Primeiro, observe o recuo, todos os blocos são recuados.
Às vezes usamos colchetes quando temos mais de uma instrução dentro
de nossos blocos, às vezes não.
Nesta declaração if on line 25, não usamos nenhum colchete.
Loops For devem se tornar algo de segunda natureza agora.
O que você realmente quer ganhar com esta atribuição são os arrays.
Então, estamos criando uma matriz chamada primos, definindo o tamanho 50, inicializando tudo para 0.
E então estamos definindo o primeiro 2 elementos
para 2 e 3 e então todo o algoritmo de 19 para as linhas 32
determinam se é primo olhando para a matriz nos números primos anteriores.
E também pular quando você está maior do que a raiz quadrada.
E então novamente você vê muito colchetes aqui para acessar matrizes
e atribuir valores para matrizes e tudo mais,
é bastante simples.
Então, vamos construir isso e veja o que acontece.
Não temos avisos, nem erros.
Se rodarmos isso, o que você vê sua saída são todos os números primos até 100
2 3 5 7 11 13 17 19 23 29 31 37 41 43 e assim por diante.
Todos esses são números primos.
E o número primo é algo que era apenas um fator por si só.
Você não pode dividir isso por qualquer outro número e não tem resto.
Portanto, 97 os únicos 2 fatores que entrar em que são 1 e 97.
Então, novamente, um pequeno programa agradável e rápido.
Eu vou fornecer a solução.
Você pode analisá-lo.
Mas, novamente, pontos-chave, tudo sobre as matrizes e também o bool padrão que usei,
que nos permitiu criar tipos de dados booleanos sem a
capital de sublinhado be também permite que você use valores
falsos verdadeiros em oposição a 1 e 0.
Espero que isto ajude. Obrigada.