VisualG Exercício 6 - Vetores - (Introdução aos Algoritmos)

Ayron Matos · 21 de outubro de 2017

Exercício 6

Escreva um algoritmo que gera os 10 primeiros números primos acima de 100 e os armazena em um

vetor X(10) escrevendo, no final, o vetor X.

algoritmo "10PrimeirosPrimos"

var
   primo: vetor[1..10] de inteiro
   c, div, i, j: inteiro
inicio
    Para j <- 1 ate 10 faca
      Para c <- 1 ate 149 faca
          div <- 0
        Para i <- 1 ate 149 faca
          Se (c%i=0) então
            div <- div + 1
          FimSe
        FimPara
          Se (div = 2) e (c > 100) então
            primo[j] <- c
          FimSe
      FimPara
    FimPara
      
      Para j <- 1 ate 10 faca
        Escreva(primo[j]:4)

fimalgoritmo

O visualg não informa qual o problema mas eu suponho que seja as variaveis..

Simon Viegas · 21 de outubro de 2017

Olá @Ayron Matos.

4 horas atrás, Ayron Matos disse:

O visualg não informa qual o problema mas eu suponho que seja as variaveis..

Tá, mais o que está acontecendo de errado? quais sintomas tem para que precise de intervenção?

obs.: qual compilador está utilizando? caso não esteja, sugiro atualizar para versão mais recente (3.0.6.5).

Vamos lá:

1) PALAVRAS RESERVADAS PELA LINGUAGEM

Aqui, ao compilar deu erro na terceira linha. Perceba que o div é azul, ou seja, é uma palavra reservada (no Visualg é chamado de "palavras-chave")... daí não pode ser utilizada para outro fim além do seu de origem. Sugeriria usar qtdDivisores, por exemplo.

2) NÚMEROS PRIMOS

A primeira coisa a se fazer é dar uma aprofundada no assunto... tentar entender o que é um número primo e descobrir forma de como achar um. Essa pesquisa já dará uma experiência sobre o tema. Enquanto aprende a programar, também vai aprendendo mais afundo conhecimentos gerais.

Identificar se um número é primo ou não é a base do algoritmo. Verificar números acima de 100 e os 10 em sequência são as restrições e requisitos. Deixa pra depois esses detalhes. A foco aqui é os primos!!!

Tente inicialmente apenas identificar se um número é primo ou não... algo como você informar um número, e retornar se ele é primo ou não. Revise a lógica necessária para isso. Faça isso (relativamente bem feito) e o restante é será apenas pequenos ajustes... posta o código aqui para analisarmos...

Pronto! quando conseguir verificar um número específico, tente verificar uma faixa de números. Não precisa armazenar nada, por exemplo, só retorne os números primos entre 100 e 200. Mais pra frente vai fazendo modificações até chegar nos requisitos finais...

No aguardo.

Ayron Matos · 22 de outubro de 2017

@Simon Viegas eu acho que não fiz exatamente como a questão queria mas pelo menos consegui chegar no mesmo resultado. A sintaxe segue abaixo:

algoritmo "10PrimeirosPrimosDepoisde100"
 
var
   primo: vetor[101..149] de inteiro
   c, divisor: inteiro
inicio
      Para c <- 101 ate 149 faca
        divisor <- 0
        Se (c%2=0) então
          divisor <- divisor + 1
        FimSe
        Se (c%3=0) então
          divisor <- divisor + 1
        FimSe
        Se (c%5=0) então
          divisor <- divisor + 1
        FimSe
        Se (c%11=0) então
          divisor <- divisor + 1
        FimSe
        Se (c%12=0) então
          divisor <- divisor + 1
        FimSe
        Se (c%c=0) então
          divisor <- divisor + 1
        FimSe
        Se (divisor=1) então
          primo[c] <- c
          Escreva(primo[c]:4)
        FimSe
      FimPara

fimalgoritmo

Simon Viegas · 22 de outubro de 2017

Olá @Ayron Matos.

1) RESULTADO APRESENTANDO x RESULTADO ESPERADO

1 hora atrás, Ayron Matos disse:

Simon Viegas eu acho que não fiz exatamente como a questão queria mas pelo menos consegui chegar no mesmo resultado.

Então, pelo meus testes não chegou ainda...

Resultado ao executar o seu código:

1 hora atrás, Ayron Matos disse:
101 103 107 109 113 119 127 131 133 137 139 149

Lista dos 10 primeiros primos acima de 100 segundo a internet:

101 103 107 109 113 127 131 137 139 149

Fonte: http://www.hypatiamat.com/apoiopdf/numerosprimosate1000-hypatiamat.pdf

Ou seja, a conta não está batendo.

2) LÓGICA PARA IDENTIFICAR NÚMEROS PRIMOS

Mesmo que o resultado estivesse batendo (que não está), como você mesmo sugere, não necessariamente queria dizer que está "certo!". É necessário ter uma metodologia por traz.... caso contrário, para exemplificar, poderia simplesmente fazer seu código assim:

algoritmo "10PrimeirosPrimosDepoisde100"
inicio
escrevaL("Segue os 10 primeiros números primos acima de 100")
escrevaL()
escrevaL("101 103 107 109 113 127 131 137 139 149")
fimalgoritmo

Entende? a resposta está certa, mas o método para achar não! O problema não é para apenas "exibir uma lista", mas sim "gera essa lista e exibir".

Então, alguns pontos que precisamos esclarecer:

2.1) Por que fazer a verificação dos restos da divisão por especificamente esses números (2, 3, 5, 11, 12 e 0)?

2.2) Por que ir de 101 a 149?

A partir da sua resposta podemos analisar o que pode ser corrigido ou melhorado.

3) SOBRE MINHA SUGESTÃO

Assim como é muito comum quando ainda não temos experiência, você está focando no resultado final... e já está tentando fazer tudo de uma vez... É como tentar aprender a correr antes de tentar aprender a andar... Eu entendo que isso não é uma boa ideia... como já citado:

21 horas atrás, Simon Viegas disse:

Tente inicialmente apenas identificar se um número é primo ou não... algo como você informar um número, e retornar se ele é primo ou não. Revise a lógica necessária para isso. Faça isso (relativamente bem feito) e o restante é será apenas pequenos ajustes... posta o código aqui para analisarmos...

Veja, é mais difícil verificar uma sequência de números é primos, sem antes ter a base para conseguir verificar apenas de um número específico antes! ou seja, foque apenas na verificação de um número específico. Quando conseguir resolver para um número, conseguirá facilmente para N números..

***

No aguardo.

Ayron Matos · 22 de outubro de 2017

Algoritmo de número primo específico:

algoritmo "Primo"

var
   n, i, divisor: inteiro
inicio
      Leia(n)
      LimpaTela
      Para i <-1 ate n faca
       Se (n%i=0) então
         divisor <- divisor + 1
       FimSe
      FimPara
      Se (divisor=2) então
         Escreva(n, " é um número primo.")
      SeNao
         Escreva(n, " não é um número primo.")
      FimSe
fimalgoritmo

adicionado 9 minutos depois

Algoritmo dos números primos de 100 a 200:

algoritmo "Primosde100a200"

var
   i,j, divisor: inteiro
inicio
     Para i <- 100 ate 200 faca
        divisor <- 0
      Para j <-1 ate i faca
       Se (i%j=0) então
         divisor <- divisor + 1
       FimSe
      FimPara
       Se (divisor=2) então
         Escreva(i)
       FimSe
     FimPara

fimalgoritmo

adicionado 28 minutos depois

Consegui!

algoritmo "10PrimeirosPrimosDepoisde100"

var
   primo: vetor[1..10] de inteiro
   c, i, j, divisor: inteiro
inicio
     i <- 100
     c <- 0
     Repita
     i <- i + 1
        divisor <- 0
      Para j <-1 ate i faca
       Se (i%j=0) então
         divisor <- divisor + 1
       FimSe
      FimPara
       Se (divisor=2) então
         c <- c + 1
         primo[c] <- i
         Escreva(primo[c])
       FimSe
     Ate (c = 10)

Muito obrigado!

Simon Viegas · 23 de outubro de 2017

Olá @Ayron Matos.

Seu código ficou muito bom!!!

Segue algumas sugestões:

1) MELHOR USO DO VETOR

Em 22/10/2017 às 16:48, Ayron Matos disse:


         primo[c] <- i
         Escreva(primo[c])

Nesse trecho acima, logo após copiar o valor na posição do vetor, essa posição está sendo impressa... o que seria o mesmo que fazer:

escreve(i)

Ou seja, o vetor deixaria de ser necessário... Acho que seria melhor primeiro cadastrar os números no vetor, e após imprimir todo o vetor de uma vez.

2) NOMENCLATURA DE VARIÁVEIS

Aqui mais servindo como demonstração e também poder servir de exemplo para você e outros usuários, segue sugestão para nomenclatura das variáveis, assim como inserido comentário para cada linha do código.

algoritmo "10PrimeirosPrimosDepoisde100"
var
   primos      :vetor[1..10] de inteiro //vetor que armazenará os números primos
   numero      :inteiro //número a ser analisado (dividendo)
   divisor     :inteiro //usado para as divisões sucessivas
   qtdPrimos   :inteiro //quantidade de primos já encontrados
   qtdDivisores:inteiro //quantidade de divisores que o número tem
inicio
numero <- 100 //inicializa com o valor anterior ao primeiro número da sequência
qtdPrimos <- 0 //inicializa a quantidade de primos já encontrados
Repita
   numero <- numero + 1 //atribui para o próximo número a ser verificado
   qtdDivisores <- 0 //zera a quantidade para o número atual
   Para divisor <-1 ate numero faca //para as divisões do 1 até o N
      Se (numero % divisor=0) ENTÃO //se divisão tem resto 0 ("é divisor")
         qtdDivisores <- qtdDivisores + 1 //atualiza a quantidade de divisores que esse númeto tem
      FimSe
   FimPara
   Se (qtdDivisores=2) ENTÃO //se número tem exatamente 2 divisores
      qtdPrimos <- qtdPrimos + 1 //atualiza a quantidade de primos já encontrados
      primos[qtdPrimos] <- numero //armazena o número no vetor
      Escreva(primos[qtdPrimos]) //*escreve a número contido no vetor
   FimSe
Ate (qtdPrimos = 10) //até chegar a quantidade primos desejados
fimAlgoritmo