VisualG Division by Zero - Por que está dando este erro?

Lucas Da Silva Aleixo · 26 de julho de 2018

Código:

algoritmo "semnome"
// Função :
// Autor :
// Data : 25/07/2018
// Seção de Declarações 
var
  v1, v2, v1_2, v2_2, c, d, resultadoC, resultadoD, v1C, v2C, v1D, v2D :inteiro
inicio
  escreva(" - Informe o primeiro valor: ")
    leia(v1)
  escreva(" - Informe o segundo valor : ")
    leia(v2)
    
  c <- 2
  d <- 3
  resultadoC <- 1
  resultadoD <- 1
  v1C <- v1
  v2C <- v2
  v1D <- v1
  v2D <- v2
  v1_2 <- v1
  v2_2 <- v2
  
  se (v1 = 0) ou (v2 = 0) então
    escreval()
    escreval(" * MMC [", v1C, ",", v2C," ]: = 0")
    escreval(" * MDC [", v1D, ",", v2D," ]: = 0")
  senao
  
  se (v1 < 0) ou (v2 < 0) então
    escreval()
    escreval(" * Este número é negativo.")
  senao
    
  enquanto (v1 + v2 <> 2) faca
    se (v1 mod c = 0) então
      resultadoC <- (resultadoC * c)
        v1 <- (v1 \ c)
    fimse

    se (v2 mod c = 0) então
      resultadoC <- (resultadoC * c)
        v2 <- (v2 \ c)
    fimse

    se (v1 mod d = 0) então
      resultadoC <- (resultadoC * d)
        v1 <- (v1 \ d)
    fimse
    
    se (v2 mod d = 0) então
      resultadoC <- (resultadoC * d)
        v2 <- (v2 \ d)
    fimse
    
    se (v1 mod v1 = 0) então
      resultadoC <- (resultadoC * v1)
        v1 <- (v1 \ v1)
    fimse
    
    se (v2 mod v2 = 0) então
      resultadoC <- (resultadoC * v2)
        v2 <- (v2 \ v2)
    fimse
    
  fimenquanto
  
  enquanto (v1_2 + v2_2 <> 2) faca
    se (v1_2 mod c = 0) e (v2_2 mod c = 0) então
      resultadoD <- (resultadoD * c)
        v1_2 <- (v1_2 \ c)
          v2_2 <- (v2_2 \ c)
    senao
      v1_2 <- (v1_2 \ c)
        v2_2 <- (v2_2 \ c)
    fimse

    se (v1_2 mod d = 0) e (v2_2 mod d = 0) então
      resultadoD <- (resultadoD * d)
        v1_2 <- (v1_2 \ d)
          v2_2 <- (v2_2 \ d)
    senao
      v1_2 <- (v1_2 \ d)
        v2_2 <- (v2_2 \ d)
    fimse

    se (v1_2 mod v1_2 = 0) e (v2_2 mod v1_2 = 0) ou (v2_2 mod v2_2 = 0) e (v1_2 mod v2_2 = 0) então
      resultadoD <- (resultadoD * v1_2)
        v1_2 <- (v1_2 \ v1_2)
          v2_2 <- (v2_2 \ v2_2)
    senao
      se (v1_2 mod v1_2 = 0) então
        v1_2 <- (v1_2 \ v1_2)
      fimse
      
      se (v2_2 mod v2_2 = 0) então
        v2_2 <- (v2_2 \ v2_2)
      fimse
    fimse

  fimenquanto
    
  escreval()
  escreval(" * MMC [", v1C, ",", v2C, " ]:", resultadoC)
  escreval(" * MDC [", v1D, ",", v2D, " ]:", resultadoD)
    
  fimse
  fimse
fimalgoritmo

O programa calcula o MMC e o MDC de dois números informados pelo usuário. Ele calcula e tudo, mas não exibe pois da o erro: Divisão por zero.

Os valores das variáveis de resultado estão corretos, porém na parte de exibir na tela os resultados aparece:

Simon Viegas · 26 de julho de 2018

Olá.

1#

11 horas atrás, Lucas Da Silva Aleixo disse:

O programa calcula o MMC e o MDC de dois números informados pelo usuário. Ele calcula e tudo, mas não exibe pois da o erro: Divisão por zero.

Esse erro deve está relacionado que, em algum momento, está tentando dividir um número por zero... Na matemáticas, isto resulta ou em "indefinido" ou em "indeterminado"... o Visualg não aceita nenhuma das possibilidades e retorna erro.

Terá que revisar a lógica do algoritmo... Sugiro que faça uma coisa de cada vez, ou seja, primeiro faz só o MMC... revisa até deixar pronto. Depois faz só o MDC... revisa até deixar pronto... depois junta os 2.

2#

11 horas atrás, Lucas Da Silva Aleixo disse:

Os valores das variáveis de resultado estão corretos, porém na parte de exibir na tela os resultados aparece:

Não, não estão. Desde quando o MMC de 6 e 4 é 24? ou seja, antes de revisar o algoritmo, é necessário revisar os conceitos... revise sobre o que é MMC e o que é MDC... ai reajusta o código.

***

No aguardo.

Lucas Da Silva Aleixo · 27 de julho de 2018

Já consegui.

Era um problema na fórmula. Eu estava tirando o MMC e o MDC de um número por vez, por isso o resultado dava em dobro. Só tive que fazer algumas alterações na fórmula.

algoritmo "MMC e MDC"

var
  v1, v2, v1_2, v2_2 :inteiro
  resultadoC, resultadoD :real
inicio
  escreval(" =============")
  escreval(" = MMC E MDC =")
  escreval(" =============")
  escreval()
  
  escreva(" - Informe o 1° valor: ")
    leia(v1)
  escreva(" - Informe o 2° valor: ")
    leia(v2)
    
  se (v1 < 0) então
    v1 <- (-(v1))
  fimse

  se (v2 < 0) então
    v2 <- (-(v2))
  fimse
    
  v1_2 <- v1
  v2_2 <- v2
  resultadoC <- 1
  resultadoD <- 1
  
  se (v1 = 0) e (v2 = 0) então
    escreval()
    escreval(" * MMC: 0")
    escreval(" * MDC: 0")
  senao
  
  se (v1 = 0) e (v2 <> 0) então
    escreval()
    escreval(" * MMC: 0")
    escreval(" * MDC:", v2_2)
  senao
  
  se (v1 <> 0) e (v2 = 0) então
    escreval()
    escreval(" * MMC: 0")
    escreval(" * MDC:", v1_2)
  senao
  
  se (v1 = v2) então
    escreval()
    escreval(" * MMC:", v1)
    escreval(" * MDC:", v1_2)
  senao
    
  enquanto (v1 % 2 = 0) e (v2 % 2 = 0) faca
    resultadoC <- (resultadoC * 2)
      v1 <- (v1 \ 2)
        v2 <- (v2 \ 2)
  fimenquanto
  
  enquanto (v1 % 3 = 0) e (v2 % 3 = 0) faca
    resultadoC <- (resultadoC * 3)
      v1 <- (v1 \ 3)
        v2 <- (v2 \ 3)
  fimenquanto
  
  enquanto (v1 % v1 = 0) e (v1 <> 1) faca
    resultadoC <- (resultadoC * v1)
      v1 <- (v1 \ v1)
  fimenquanto
  
  enquanto (v2 % v2 = 0) e (v2 <> 1) faca
    resultadoC <- (resultadoC * v2)
      v2 <- (v2 \ v2)
  fimenquanto
  
  enquanto (v1_2 % 2 = 0) e (v2_2 % 2 = 0) faca
    resultadoD <- (resultadoD * 2)
      v1_2 <- (v1_2 \ 2)
        v2_2 <- (v2_2 \ 2)
  fimenquanto
  
  enquanto (v1_2 % 3 = 0) e (v2_2 % 3 = 0) faca
    resultadoD <- (resultadoD * 3)
      v1_2 <- (v1_2 \ 3)
        v2_2 <- (v2_2 \ 3)
  fimenquanto
  
  enquanto (v1_2 % v1_2 = 0) e (v2_2 = v1_2) faca
    resultadoD <- (resultadoD * 2)
      v1_2 <- (v1_2 \ v1_2)
        v2_2 <- (v2_2 \ v2_2)
  fimenquanto
  
  escreval()
  escreval(" * MMC:", resultadoC)
  escreval(" * MDC:", resultadoD)
  
  fimse
  fimse
  fimse
  fimse
fimalgoritmo

Simon Viegas · 27 de julho de 2018

Em 27/07/2018 às 15:18, Lucas Da Silva Aleixo disse:


  se (v1 < 0) então
    v1 <- (-(v1))
  fimse

  se (v2 < 0) então
    v2 <- (-(v2))
  fimse

Para que está fazendo isso? dá para explicar?

adicionado 7 minutos depois

Outros pontos:

-̶ ̶O̶s̶ ̶s̶e̶ ̶s̶ã̶o̶ ̶e̶x̶c̶l̶u̶d̶e̶n̶t̶e̶s̶ ̶e̶n̶t̶r̶e̶ ̶s̶i̶,̶ ̶l̶o̶g̶o̶,̶ ̶a̶ ̶l̶ó̶g̶i̶c̶a̶ ̶s̶u̶g̶e̶r̶e̶ ̶u̶t̶i̶l̶i̶z̶a̶r̶ ̶s̶e̶n̶ã̶o̶.̶

- Qual a relação direta entre 2 e 3; e o cálculo MMC e MDC?

adicionado 26 minutos depois

ADENDO....

Falando as mesmas coisas tentando ser mais direto:

- MDC e MMC é apenas para número positivos;

-̶ ̶Q̶u̶a̶n̶d̶o̶ ̶a̶s̶ ̶c̶o̶n̶d̶i̶ç̶õ̶e̶s̶ ̶s̶ã̶o̶ ̶m̶u̶t̶u̶a̶m̶e̶n̶t̶e̶ ̶e̶x̶c̶l̶u̶d̶e̶n̶t̶e̶s̶,̶ ̶s̶e̶ ̶u̶m̶a̶ ̶f̶o̶r̶ ̶v̶e̶r̶d̶a̶d̶e̶i̶r̶a̶,̶ ̶n̶ã̶o̶ ̶f̶a̶z̶ ̶s̶e̶n̶t̶i̶d̶o̶ ̶v̶e̶r̶i̶f̶i̶c̶a̶r̶ ̶a̶s̶ ̶o̶u̶t̶r̶a̶s̶ ̶(̶d̶a̶í̶ ̶o̶ ̶s̶e̶n̶ã̶o̶ ̶p̶a̶r̶a̶ ̶s̶ó̶ ̶v̶e̶r̶i̶f̶i̶c̶a̶r̶ ̶"̶s̶e̶ ̶a̶ ̶a̶n̶t̶e̶r̶i̶o̶r̶ ̶f̶o̶r̶ ̶f̶a̶l̶s̶a̶"̶)̶;̶

- Nem todo número é decomposto apenas de 2 e/ou 3... experimente inserir, por exemplo, 7 e 14. Deu certo?

Lucas Da Silva Aleixo · 28 de julho de 2018

20 horas atrás, Simon Viegas disse:
20 horas atrás, Lucas Da Silva Aleixo disse:
  se (v1 < 0) então
    v1 <- (-(v1))
  fimse

  se (v2 < 0) então
    v2 <- (-(v2))
  fimse
Para que está fazendo isso? dá para explicar?

É que caso o usuário insira um valor negativo, automaticamente é convertido para um valor positivo.

20 horas atrás, Simon Viegas disse:

Outros pontos:

- Os se são excludentes entre si, logo, a lógica sugere utilizar senão.

- Qual a relação direta entre 2 e 3; e o cálculo MMC e MDC?

adicionado 26 minutos depois

ADENDO....

Falando as mesmas coisas tentando ser mais direto:

- MDC e MMC é apenas para número positivos;

- Quando as condições são mutuamente excludentes, se uma for verdadeira, não faz sentido verificar as outras (daí o senão para só verificar "se a anterior for falsa");

- Nem todo número é decomposto apenas de 2 e/ou 3... experimente inserir, por exemplo, 7 e 14. Deu certo?

Coloquei o 2 e o 3 pois são os 2 primeiros números primos, então o programa vai dividindo até chegar em 1, se não chegar resultará em um número primo, para estes casos coloquei essas linhas de comando.

enquanto (v1_2 % v1_2 = 0) e (v2_2 = v1_2) faca
  resultadoD <- (resultadoD * 2)
    v1_2 <- (v1_2 \ v1_2)
      v2_2 <- (v2_2 \ v2_2)
fimenquanto

enquanto (v1_2 % v1_2 = 0) e (v2_2 = v1_2) faca
  resultadoD <- (resultadoD * 2)
    v1_2 <- (v1_2 \ v1_2)
      v2_2 <- (v2_2 \ v2_2)
fimenquanto

O senão não coloquei pois são muitas condições, não apenas uma. Se uma resultar em falso, a outra não necessariamente resultará em verdadeiro.

Simon Viegas · 28 de julho de 2018

1#

7 horas atrás, Lucas Da Silva Aleixo disse:

É que caso o usuário insira um valor negativo, automaticamente é convertido para um valor positivo.

Tá, mas quem disse que pode converter para positivo?

Veja... x é x, e -x é -x... não pode simplesmente mudar o sinal. Já pensou? vou fazer isso com o saldo da minha conta, rs.

Brincadeiras a parte, se atente que:

Em 27/07/2018 às 15:51, Simon Viegas disse:

- MDC e MMC é apenas para número positivos;

Ou seja, apenas "não existe" para números nulos ou negativos!

Por exemplo: no mundo dos Reais, quanto é a raiz quadrada de -9? Então, não se pode "transformar" em 9 e fazer a conta e dizer que é 3... ou seja, nesse contexto, simplesmente não existe raiz quadrada de números negativos e pronto.

2#

7 horas atrás, Lucas Da Silva Aleixo disse:

Coloquei o 2 e o 3 pois são os 2 primeiros números primos, então o programa vai dividindo até chegar em 1, se não chegar resultará em um número primo, para estes casos coloquei essas linhas de comando.

Esta é uma conclusão precipitada... que em outras palavras é o mesmo que dizer ERRADA. Como já citado:

7 horas atrás, Lucas Da Silva Aleixo disse:

Nem todo número é decomposto apenas de 2 e/ou 3..

Tente decompor 385 apenas com o 2 e 3.

Dá? Não né? Então 385 é primo?

(basta ir multiplicando qualquer um dos infinitos primos diferentes de 2 e 3, por outro desta mesma categoria, que chegará a números que não são divisíveis por 2 e 3 e não é primos)

RESUMINDO:

Não existe motivos lógicos para "privilegiar" o 2 e 3. Você precisa:

Em 26/07/2018 às 08:28, Simon Viegas disse:

...revisar os conceitos... revise sobre o que é MMC e o que é MDC... ai reajusta o código.

A outra dica também é válida:

Em 26/07/2018 às 08:28, Simon Viegas disse:

Sugiro que faça uma coisa de cada vez, ou seja, primeiro faz só o MMC... revisa até deixar pronto. Depois faz só o MDC... revisa até deixar pronto... depois junta os 2.

***

RESUMINDO

Só calcule o MMC para número positivos! Depois só o MDC para números positivos.. Apenas não use 0 ou números negativos!

Pense assim... o que é um MMC? Se aprofunde no tema... revise o conteúdo. Daí, faça contas no papel... entenda o "algoritmo" que fez para resolver... Esqueça que Visualg existe.... como faria para calcular o MMC de 4 e 12? e para 35 e 280?

Primeiro aprenda a fazer a conta e entender o método. Visualg será só uma ferramenta para automatizar.

adicionado 16 minutos depois

3#

Sobre:

7 horas atrás, Lucas Da Silva Aleixo disse:

O senão não coloquei pois são muitas condições, não apenas uma. Se uma resultar em falso, a outra não necessariamente resultará em verdadeiro.

Na verdade verdade o seu código já está com o senão.. eu apenas que não tinha visto, talvez por não está indentado e/ou com espaços entre si, sei lá... rs. Ignore essa parte!

Em 27/07/2018 às 15:18, Lucas Da Silva Aleixo disse:


se (v1 = 0) e (v2 = 0) então
   escreval()
   escreval(" * MMC: 0")
   escreval(" * MDC: 0")
senao
   se (v1 = 0) e (v2 <> 0) então
      escreval()
      escreval(" * MMC: 0")
      escreval(" * MDC:", v2_2)
   senao
      se (v1 <> 0) e (v2 = 0) então
         escreval()
         escreval(" * MMC: 0")
         escreval(" * MDC:", v1_2)
      senao
         se (v1 = v2) então
            escreval()
            escreval(" * MMC:", v1)
            escreval(" * MDC:", v1_2)
         senao

Está certo assim... isso que estava sugerido! (mas já estava)

Lucas Da Silva Aleixo · 29 de julho de 2018

Modifiquei algumas coisas no código:

- MMC e o MDC somente para números positivos.

- Agora ao invés de usar o 2 e o 3 para fazer os cálculos, são gerados todos os números primos de 1 a 100, ou seja, faz as contas com todos os números primos gerados. Acho que é quase impossível não resultar em um número primo dessa maneira.

. Novo Algoritmo:

algoritmo "MMC e MDC"
// Função : Calcular o MMC e o MDC de dois valores informados pelo usuário.
// Autor :
// Data : 29/07/2018
// Seção de Declarações
var
  divisores :vetor [1..100] de inteiro //Para guardar os divisores
  primos :vetor [1..100] de inteiro //Para guardar os números primos
  v1, v2, v1_2, v2_2, v1I, v2I, x, y, divisor :inteiro
  resultadoC, resultadoD :real
inicio
  escreval(" =============")
  escreval(" = MMC E MDC =")
  escreval(" =============")
  escreval()

  escreva(" - Informe o primeiro valor: ")
    leia(v1)
  escreva(" - Informe o segundo valor: ")
    leia(v2)

//Verifica se o número é negativo

  se (v1 < 0) ou (v2 < 0) então
    escreval()
    escreval(" * Número(s) negativo(s).")
  senao

   //Verifica se o número é nulo

    se (v1 = 0) ou (v2 = 0) então
      escreval()
      escreval(" * Número(s) nulo(s).")
    senao

      //As variáveis de resultados não podem ser iguais a zero porque irão ser multiplicadas.

      v1I <- v1
      v2I <- v2
      v1_2 <- v1
      v2_2 <- v2
      resultadoC <- 1
      resultadoD <- 1

      //Gera quantos divisores cada número de 1 até 100 possui. A quantidade é armazenada no vetor "divisores".

      para x de 1 ate 100 faca
         divisor <- 0
         para y de 1 ate 100 faca
            se (x % y = 0) então
               divisor <- (divisor + 1)
               divisores[x] <- divisor
            fimse
         fimpara
      fimpara

      //Verifica quais números são primos. Caso o número possuir dois divisores, então ele é primo. Os números primos são armazenados no vetor "primos".

      para x de 1 ate 100 faca
         se (divisores[x] = 2) então
            primos[x] <- x
         fimse
      fimpara

      //Cálculo do MMC

      //Verifica quais posições na memória do vetor "primos" possuem números primos.

      enquanto (v1 + v2 <> 2) faca
         para x de 1 ate 100 faca
            se (primos[x] <> 0) então

               //Enquanto os dois forem diferentes de 1, serão divididos e o resultado será multiplicado pelos números primos armazenados.

               enquanto (v1 % primos[x] = 0) e (v2 % primos[x] = 0) e (v1 <> 1) e (v2 <> 1) faca
                  resultadoC <- (resultadoC * primos[x])
                  v1 <- (v1 \ primos[x])
                  v2 <- (v2 \ primos[x])
               fimenquanto
            fimse
         fimpara

         //Caso resulte em um número primo

         se (v1 = v2) e (v1 % v1 = 0) e (v1 <> 1) então
            resultadoC <- (resultadoC * v1)
            v1 <- (v1 \ v1)
            v2 <- (v2 \ v2)
         senao

            se (v1 % v1 = 0) e (v1 <> 1) então
               resultadoC <- (resultadoC * v1)
               v1 <- (v1 \ v1)
            fimse

            se (v2 % v2 = 0) e (v2 <> 1) então
               resultadoC <- (resultadoC * v2)
               v2 <- (v2 \ v2)
            fimse

         fimse

      fimenquanto

      //Cálculo do MDC

      //Enquanto os dois forem diferentes de 1, serão divididos e o resultado será multiplicado pelos números primos.

      enquanto (v1_2 + v2_2 <> 1) faca
         para x de 1 ate 100 faca
            se (primos[x] <> 0) então
               enquanto (v1_2 % primos[x] = 0) e (v2_2 % primos[x] = 0) e (v1_2 <> 1) e (v2_2 <> 1) faca
                  resultadoD <- (resultadoD * primos[x])
                  v1_2 <- (v1_2 \ primos[x])
                  v2_2 <- (v2_2 \ primos[x])

                  //Se somente 1 número for divisível, o resultado não muda e apenas os valores serão divididos.

               senao

                  se (primos[x] <> 0) então
                     se (v1_2 % primos[x] = 0) ou (v2_2 % primos[x] = 0) e (v1_2 <> 1) e (v2_2 <> 1) então
                        v1_2 <- (v1_2 \ primos[x])
                        v2_2 <- (v2_2 \ primos[x])
                     fimse
                  fimse

                  //Caso os números resultantes sejam primos

                  se (v1_2 = v2_2) e (v1_2 % v1_2 = 0) e (v1_2 <> 1) então
                     resultadoD <- (resultadoD * v1_2)
                     v1_2 <- (v1_2 \ v1_2)
                     v2_2 <- (v2_2 \ v2_2)
                  senao
                     v1_2 <- (v1_2 \ v1_2)
                     v2_2 <- (v2_2 \ v2_2)
                  fimse

               fimse
            fimpara
         fimpara

      fimenquanto

      //Exibe na tela os resultados finais

      escreval()
      escreval(" * MMC[", v1I, ",", v2I, " ]:", resultadoC)
      escreval(" * MDC[", v1I, ",", v2I, " ]:", resultadoD)
      escreval()

    fimse
  fimse
fimalgoritmo

- Porém agora está ocorrendo um erro:

. VisuAlg encontrou o seguinte problema em seu algoritmo, na linha 154:

Era esperado encontrar FIMPARA

Me certifiquei de todos os comandos PARA que coloquei tinham um FIMPARA. Saberia me dizer porque está ocorrendo este erro?

Simon Viegas · 30 de julho de 2018

Olá.

Sobre:

12 horas atrás, Lucas Da Silva Aleixo disse:

- Porém agora está ocorrendo um erro:

. VisuAlg encontrou o seguinte problema em seu algoritmo, na linha 154:

Era esperado encontrar FIMPARA

Me certifiquei de todos os comandos PARA que coloquei tinham um FIMPARA. Saberia me dizer porque está ocorrendo este erro?

Temos duas questão aqui:

- O seu código está com algum erro de sintaxe, mas Visualg não sabe verificar isso muito bem em tempo de compilação.

- Nem sempre o erro, no caso em tempo de execução, aponta exatamente para o erro real... Infelizmente tem que analisar o código na tora!

Para tentar achar o erro:

- Pressione CTRL+G no Visuagl para fazer a indentação automática;

- Vai reanalisando parte por parte do código. Por exemplo:

Perceba como o senão está fora do lugar... está alinhado com o enquanto... e por sua vez, o enquanto está sem o seu fimEnquanto.

Ao reajustar, pressione CTRL+G novamente... e reanalisa...

Por ai vai.

No aguardo.

adicionado 20 minutos depois

ADENDO:

Pegando o gancho da sua lógica, para simplificar um pouco o processo do uso dos primos, poderia fazer algo assim:

         //Verifica quais números são primos. Caso o número possuir dois divisores, ENTÃO ele é primo. Os números primos são armazenados no vetor "primos".
         p <- 0
         para x de 1 ate 100 faca
            se (divisores[x] = 2) ENTÃO
               p <- p+1
               primos[p] <- x
            fimse
         fimpara

Desta forma, primos[] só terá primos... indo da posição 1 até a p.

Tanto no seu código, tanto neste, dá para juntar em um para só.

Ficaria algo como:

//Gera quantos divisores cada número de 1 até 100 possui. A quantidade é armazenada no vetor "divisores".
p <- 0 //zera o contador de primos encontrados
para x de 1 ate 100 faca //para cada um dos 100 primeiros números positivos
   divisor <- 0 //zera o contador de divisores do número
   para y de 1 ate 100 faca //para cada um dos potenciais divisores
      se (x % y = 0) ENTÃO //se um for divisível pelo outro
         divisores[x] <- divisores[x]+1 //atualiza o contador de divisores
      fimse
   fimpara
   se (divisores[x] = 2) ENTÃO //se tiver exatamente 2 divisores é primo
      p <- p+1 //atualiza a quantidade de primos
      primos[p] <- x //armazena o número na "lista de primos"
   fimse
fimpara

Perceba que desta forma não necessitaria mais armazenar a quantidade de cada um num vetor... pois é verificado logo após descobrir... logo poderia ficar com algo assim:

//Gera quantos divisores cada número de 1 até 100 possui. A quantidade é armazenada no vetor "divisores".
p <- 0 //zera o contador de primos encontrados
para x de 1 ate 100 faca //para cada um dos 100 primeiros números positivos
   qtdDivisores <- 0 //zera o contador de divisores do número
   para y de 1 ate 100 faca //para cada um dos potenciais divisores
      se (x % y = 0) ENTÃO //se um for divisível pelo outro
         qtdDivisores <- qtdDivisores+1 //atualiza o contador de divisores
      fimse
   fimpara
   se (qtdDivisores = 2) ENTÃO //se tiver exatamente 2 divisores é primo
      p <- p+1 //atualiza a quantidade de primos
      primos[p] <- x //armazena o número na "lista de primos"
   fimse
fimpara

Então, como é parte fundamental do programa... para ter uma melhor garantia que está funcionando, poderia fazer um programa a parte para testar. Ex.:

algoritmo "Teste lista de primos"
var
   primos      :vetor [1..100] de inteiro //Para guardar os números primos
   qtdDivisores:inteiro
   x,y         :inteiro
   p           :inteiro

inicio
//Gera quantos divisores cada número de 1 até 100 possui. A quantidade é armazenada no vetor "divisores".
p <- 0 //zera o contador de primos encontrados
para x de 1 ate 100 faca //para cada um dos 100 primeiros números positivos
   qtdDivisores <- 0 //zera o contador de divisores do número
   para y de 1 ate 100 faca //para cada um dos potenciais divisores
      se (x % y = 0) ENTÃO //se um for divisível pelo outro
         qtdDivisores <- qtdDivisores+1 //atualiza o contador de divisores
      fimse
   fimpara
   se (qtdDivisores = 2) ENTÃO //se tiver exatamente 2 divisores é primo
      p <- p+1 //atualiza a quantidade de primos
      primos[p] <- x //armazena o número na "lista de primos"
   fimse
fimpara

//Imprime o vetor na tela
para x de 1 ate p faca
   escreva (primos[x]," ")
fimPara

fimalgoritmo

Aqui pareceu que está funcionando... Daí, caso queira, ajusta para o seu código.

Lucas Da Silva Aleixo · 30 de julho de 2018

Haviam dois comandos enquanto desnecessários, e um para fora do lugar.

Usei aquela dica sobre logo após verificar se o número é primo.

O vetor para guardar os números primos deixei com apenas 25 posições, já que só existem 25 números primos entre 1 e 100.

Agora deu certo, sem nenhum erro.

algoritmo "MMC e MDC"
// Função : Calcular o MMC e o MDC de dois valores informados pelo usuário.
// Autor :
// Data : 29/07/2018
// Seção de Declarações
var
  primos :vetor [1..25] de inteiro //Para guardar os números primos
  v1, v2, v1_2, v2_2, v1I, v2I, x, y, divisor, p :inteiro
  resultadoC, resultadoD :real
inicio
  escreval(" =============")
  escreval(" = MMC E MDC =")
  escreval(" =============")
  escreval()

  escreva(" - Informe o primeiro valor: ")
    leia(v1)
  escreva(" - Informe o segundo valor: ")
    leia(v2)

//Verifica se o número é negativo

  se (v1 < 0) ou (v2 < 0) então
    escreval()
    escreval(" * Número(s) negativo(s).")
  senao

   //Verifica se o número é nulo

   se (v1 = 0) ou (v2 = 0) então
      escreval()
      escreval(" * Número(s) nulo(s).")
   senao

      //As variáveis de resultados não podem ser iguais a zero porque irão ser multiplicadas.

      v1I <- v1
      v2I <- v2
      v1_2 <- v1
      v2_2 <- v2
      resultadoC <- 1
      resultadoD <- 1

      //Gera quantos divisores cada número de 1 até 100 possui. A quantidade é armazenada na variável "divisor".

      para x de 1 ate 100 faca
         divisor <- 0
         para y de 1 ate 100 faca
            se (x % y = 0) então
               divisor <- (divisor + 1)
            fimse
         fimpara

         //Verifica quais números são primos. Caso o número possuir dois divisores, então ele é primo. Os números primos são armazenados no vetor "primos".

         se (divisor = 2) então
            p <- (p + 1)
            primos[p] <- x
         fimse
      fimpara

      //Cálculo do MMC

      //Enquanto os dois não resultarem em algum número primo, serão divididos e o resultado será multiplicado pelos números primos armazenados.

      para x de 1 ate 25 faca
         enquanto (v1 % primos[x] = 0) e (v2 % primos[x] = 0) e (v1 <> 1) e (v2 <> 1) e (x <> 25) faca
            resultadoC <- (resultadoC * primos[x])
            v1 <- (v1 \ primos[x])
            v2 <- (v2 \ primos[x])
         fimenquanto
      fimpara

      //Caso resulte em um número primo

      se (v1 = v2) e (v1 % v1 = 0) e (v1 <> 1) então
         resultadoC <- (resultadoC * v1)
         v1 <- (v1 \ v1)
         v2 <- (v2 \ v2)
      fimse

      se (v1 % v1 = 0) e (v1 <> 1) então
         resultadoC <- (resultadoC * v1)
         v1 <- (v1 \ v1)
      fimse

      se (v2 % v2 = 0) e (v2 <> 1) então
         resultadoC <- (resultadoC * v2)
         v2 <- (v2 \ v2)
      fimse

      //Cálculo do MDC

      //Enquanto os dois não resultarem em algum número primo, serão divididos e o resultado será multiplicado pelos números primos.

      para x de 1 ate 25 faca
         enquanto (v1_2 % primos[x] = 0) e (v2_2 % primos[x] = 0) e (v1_2 <> 1) e (v2_2 <> 1) faca
            resultadoD <- (resultadoD * primos[x])
            v1_2 <- (v1_2 \ primos[x])
            v2_2 <- (v2_2 \ primos[x])

            //Se somente 1 número for divisível, o resultado não muda e apenas os valores serão divididos.

            se (v1_2 % primos[x] = 0) ou (v2_2 % primos[x] = 0) e (v1_2 <> 1) e (v2_2 <> 1) então
               v1_2 <- (v1_2 \ primos[x])
               v2_2 <- (v2_2 \ primos[x])
            fimse
         fimenquanto
      fimpara

      //Caso os números resultantes sejam primos

      se (v1_2 = v2_2) e (v1_2 % v1_2 = 0) e (v1_2 <> 1) então
         resultadoD <- (resultadoD * v1_2)
         v1_2 <- (v1_2 \ v1_2)
         v2_2 <- (v2_2 \ v2_2)
      senao
         v1_2 <- (v1_2 \ v1_2)
         v2_2 <- (v2_2 \ v2_2)
      fimse

      //Exibe na tela os resultados finais

      escreval()
      escreval(" * MMC[", v1I, ",", v2I, " ]:", resultadoC)
      escreval(" * MDC[", v1I, ",", v2I, " ]:", resultadoD)
      escreval()

    fimse
  fimse
fimalgoritmo

Simon Viegas · 30 de julho de 2018

1#

Sobre:

1 hora atrás, Lucas Da Silva Aleixo disse:

O vetor para guardar os números primos deixei com apenas 25 posições, já que só existem 25 números primos entre 1 a 100.

Observação inicial.: Talvez não tenha problemas deixar com 25, é mais para refletir...

Tá! mas como você sabe que só tem 25 primos entre 1 e 100? seria necessário citar ou demonstrar como sabe disso no contexto...

Ou seja, creio eu que não deve existe uma fórmula para saber quantos primos existem entre uma faixa de números... de certo modo, está dando a subentender que o programador já sabe quantos tem, que por sua vez sugere que já sabe quais quais são os primos...

Seria mais lógico já declarar os valores, algo como:

inicio
primos[1]<=2
primos[2]<=3
primos[3]<=5
...

Entende? a "fonte" que diz a quantidade de primos pode ser a mesma que já diz quais são os primos. Talvez seria melhor deixar 100 mesmo...

2#

Sobre:

//Verifica se o número é negativo

Pequeno detalhe: não seria "o" número. Pois está verificando 2. Seria mais para algo como "//Verifica se algum número é negativo". O mesmo princípio vale para os nulos. "//Verifica se algum número é nulo".

3#

Sobre:

1 hora atrás, Lucas Da Silva Aleixo disse:


escreval(" * MMC[", v1I, ",", v2I, " ]:", resultadoC)
escreval(" * MDC[", v1I, ",", v2I, " ]:", resultadoD)

Você está usando v1I e v1I para exibir o número original e usando v1 e v2 para calcular o MMC.. mas acho que deveria fazer o contrário... ou seja, o lido não se mexe, e usa a cópia para calcular. Assim como foi feito no MDC.

De um modo geral, só precisaria de um par de variável... basta antes de calcular cada um, atualizar esse auxiliar. Ex.:

      v1_2 <- v1
      v2_2 <- v2

RESUMINDO:

São 2 pontos.

- Você está usando a variável original no MMC;

- Poderia um mesmo par de auxiliares para os dois cálculos...

4#

Sobre algumas verificações:

se ... (v1 % v1 = 0) ... então

Veja, em 100% das vezes, o resultado será o mesmo! logo, não faz sentido verificar algo que é estático!

Ou implementou errado alguma lógica, ou a lógica em si está errada...

Perceba esse trecho:

1 hora atrás, Lucas Da Silva Aleixo disse:


      //Caso resulte em um número primo

      se (v1 = v2) e (v1 % v1 = 0) e (v1 <> 1) ENTÃO
         resultadoC <- (resultadoC * v1)
         v1 <- (v1 \ v1)
         v2 <- (v2 \ v2)
      fimse

      se (v1 % v1 = 0) e (v1 <> 1) ENTÃO
         resultadoC <- (resultadoC * v1)
         v1 <- (v1 \ v1)
      fimse

      se (v2 % v2 = 0) e (v2 <> 1) ENTÃO
         resultadoC <- (resultadoC * v2)
         v2 <- (v2 \ v2)
      fimse

é o mesmo que:

      se (v1 = v2) e (v1 <> 1) ENTÃO
         resultadoC <- (resultadoC * v1)
         v1 <- (v1 \ v1)
         v2 <- (v2 \ v2)
      fimse
      se (v1 <> 1) ENTÃO
         resultadoC <- (resultadoC * v1)
      fimse
      se (v2 <> 1) ENTÃO
         resultadoC <- (resultadoC * v2)
      fimse

Outro ponto importante é que a frase "Caso resulte em um número primo" cai no mesmo caso:

Em 28/07/2018 às 19:27, Simon Viegas disse:

Esta é uma conclusão precipitada

Pois nem sempre que v1 ou v2 for diferente de 1, era será primo. Entende? é interessante se atentar ao escopo antes de criar afirmações.

PS: eu preferiria deixar para você mesmo refletir sobre o que eu quis dizer... mas seria o seguinte... no contexto de sua lógica, o que está se verificando é se v1 ou v2 ainda necessitaria ser decomposto em mais outros números primos... isso vai ocorrer toda vez que "um número tiver primos que o outro não contenha"... Por sinal, isso pode ocorrer para ambos os números. Perceba que no para está justamente "retirando" o que é comum entre os 2... logo, o que vai sobrar é o que não é comum... o detalhe é que não necessariamente sobrará um único primo.

***

Talvez tenha outros pequenos detalhes... mas por enquanto é isso.

No aguardo.

Lucas Da Silva Aleixo · 30 de julho de 2018

15 horas atrás, Simon Viegas disse:

1#

Sobre:

18 horas atrás, Lucas Da Silva Aleixo disse:

O vetor para guardar os números primos deixei com apenas 25 posições, já que só existem 25 números primos entre 1 a 100.

Observação inicial.: Talvez não tenha problemas deixar com 25, é mais para refletir...

Tá! mas como você sabe que só tem 25 primos entre 1 e 100? seria necessário citar ou demonstrar como sabe disso no contexto...

Ou seja, creio eu que não deve existe uma fórmula para saber quantos primos existem entre uma faixa de números... de certo modo, está dando a subentender que o programador já sabe quantos tem, que por sua vez sugere que já sabe quais quais são os primos...

Ok, vou colocar o 100 ao invés do 25.

15 horas atrás, Simon Viegas disse:
2#

Sobre:
//Verifica se o número é negativo
Pequeno detalhe: não seria "o" número. Pois está verificando 2. Seria mais para algo como "//Verifica se algum número é negativo". O mesmo princípio vale para os nulos. "//Verifica se algum número é nulo".

É mesmo, nem tinha reparado. Já mudei aqui.

15 horas atrás, Simon Viegas disse:
3#

Sobre:
18 horas atrás, Lucas Da Silva Aleixo disse:
escreval(" * MMC[", v1I, ",", v2I, " ]:", resultadoC)
escreval(" * MDC[", v1I, ",", v2I, " ]:", resultadoD)
Você está usando v1I e v1I para exibir o número original e usando v1 e v2 para calcular o MMC.. mas acho que deveria fazer o contrário... ou seja, o lido não se mexe, e usa a cópia para calcular. Assim como foi feito no MDC.

De um modo geral, só precisaria de um par de variável... basta antes de calcular cada um, atualizar esse auxiliar. Ex.:
      v1_2 <- v1
      v2_2 <- v2

Usei a variável v1I e v2I, porque o "I" representa "Inicial", ou seja valor inicial, acho que fica mais didático assim, porque na teoria o usuário está colocando aqueles valores para serem calculados e não para aparecerem no final.

15 horas atrás, Simon Viegas disse:
4#

Sobre algumas verificações:
se ... (v1 % v1 = 0) ... então
Veja, em 100% das vezes, o resultado será o mesmo! logo, não faz sentido verificar algo que é estático!

Ou implementou errado alguma lógica, ou a lógica em si está errada...

OK, retirei esta parte.

15 horas atrás, Simon Viegas disse:

Outro ponto importante é que a frase "Caso resulte em um número primo" cai no mesmo caso:

Em ‎28‎/‎07‎/‎2018 às 19:27, Simon Viegas disse:

Esta é uma conclusão precipitada

Pois nem sempre que v1 ou v2 for diferente de 1, era será primo. Entende? é interessante se atentar ao escopo antes de criar afirmações.

Não tenho certeza mas...

Antes desta parte do ser diferente de 1, os números passam pelo processo de contas, eles serão divididos por todos os números primos de 1 ate 100, até não serem divisíveis por nenhum deles, o que só ocorre com os números primos.

Já que as variáveis v1 e v2 são do tipo inteiro e o VisualG só aceita 8 dígitos para variáveis de número inteiro, acho que não existe nenhum número não primo de até 8 dígitos que não seja divisível por: 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 ou que não resulte em um número primo, pois cada vez que o número vai sendo dividido, menor ele fica, e as chances de ele ser divisível por algum desses números aumentam e ai é certo que ele resultará em um número primo.

A parte do (v1 <> 1) e (v2 <> 1) é para confirmar se a conta não acabou.

Modificações:

1° - Coloquei um comando enquanto v1, v2 <> 0, pois no enunciado pede um número não determinados de pares.

2° - Troquei o 25 pelo 100 novamente.

3° - Retirei a parte para verificar se o número é nulo, já que para quando o usuário digitar 0 é para sair, então a cada v1 lido, ele verifica se é igual a zero, o mesmo ocorre com o v2.

4° Consertei as frases (exceto a do número primo)

5° Tirei aquela parte do (v1 % v1 = 0)

6° Coloquei uma parte para verificar se os números são iguais, porque caso for o MMC e o MDC serão iguais aos valores. Se não tiver esta parte a conta sairá errada.

algoritmo "Exercício 18"
// Função : Calcular o MMC e o MDC de dois valores informados pelo usuário.
// Autor :
// Data : 30/07/2018
// Seção de Declarações
var
primos :vetor [1..100] de inteiro //Para guardar os números primos
v1, v2, v1_2, v2_2, v1I, v2I, x, y, divisor, p, n, j :inteiro
resultadoC, resultadoD :real
inicio
v1 <- 1
v2 <- 1

enquanto (v1 <> 0) ou (v2 <> 0) faca
   limpatela
   escreval(" =============")
   escreval(" = MMC E MDC =")
   escreval(" =============")
   escreval()
   escreval(" * Digite 0 para sair.")
   escreval()
   escreva(" - Informe o primeiro valor: ")
   leia(v1)

   se (v1 = 0) então
      v2 <- 0
      interrompa
   senao

      escreva(" - Informe o segundo valor: ")
      leia(v2)

      se (v2 = 0) então
         v1 <- 0
         interrompa
      senao

         //Verifica se algum número é negativo

         se (v1 < 0) ou (v2 < 0) então
            escreval()
            escreval(" * Número(s) negativo(s).")
            escreval()
            escreval(" - Pressione F9 para continuar...")
            pausa
         senao

            //Verifica se os números são iguais

            se (v1 = v2) então
               escreval()
               escreval(" * MMC[", v1, ",", v2, " ]:", v1)
               escreval(" * MDC[", v1, ",", v2, " ]:", v2)
               escreval()
               escreval(" - Pressione F9 para continuar...")
               pausa
            senao

               //As variáveis de resultados não podem ser iguais a zero porque irão ser multiplicadas.

               v1I <- v1
               v2I <- v2
               v1_2 <- v1
               v2_2 <- v2
               resultadoC <- 1
               resultadoD <- 1

               //Gera quantos divisores cada número de 1 até 100 possui. A quantidade é armazenada na variável "divisor".

               para x de 1 ate 100 faca
                  divisor <- 0 //Zera os divisores
                  para y de 1 ate 100 faca
                     se (x % y = 0) então
                        divisor <- (divisor + 1)
                     fimse
                  fimpara

                  //Verifica quais números são primos. Caso o número possuir dois divisores, então ele é primo. Os números primos são armazenados no vetor "primos".

                  se (divisor = 2) então
                     p <- (p + 1)
                     primos[p] <- x
                  fimse
               fimpara

               //Cálculo do MMC

               //Enquanto os dois não resultarem em algum número primo, serão divididos e o resultado será multiplicado pelos números primos.

               para x de 1 ate 100 faca
                  se (primos[x] <> 0) então
                     enquanto (v1 % primos[x] = 0) e (v2 % primos[x] = 0) e (v1 <> 1) e (v2 <> 1) faca
                        resultadoC <- (resultadoC * primos[x])
                        v1 <- (v1 \ primos[x])
                        v2 <- (v2 \ primos[x])
                     fimenquanto
                  fimse
               fimpara

               //Caso resulte em um número primo

               se (v1 = v2) e (v1 <> 1) então
                  resultadoC <- (resultadoC * v1)
                  v1 <- (v1 \ v1)
                  v2 <- (v2 \ v2)
               fimse

               se (v1 <> 1) então
                  resultadoC <- (resultadoC * v1)
                  v1 <- (v1 \ v1)
               fimse

               se (v2 <> 1) então
                  resultadoC <- (resultadoC * v2)
                  v2 <- (v2 \ v2)
               fimse

               //Cálculo do MDC

               //Enquanto os dois não resultarem em algum número primo, serão divididos e o resultado será multiplicado pelos números primos.

               para x de 1 ate 100 faca
                  se (primos[x] <> 0) então
                     enquanto (v1_2 % primos[x] = 0) e (v2_2 % primos[x] = 0) e (v1_2 <> 1) e (v2_2 <> 1) faca
                        resultadoD <- (resultadoD * primos[x])
                        v1_2 <- (v1_2 \ primos[x])
                        v2_2 <- (v2_2 \ primos[x])

                        //Se somente 1 número for divisível, o resultado não muda e apenas os valores serão divididos.

                        se (v1_2 % primos[x] = 0) ou (v2_2 % primos[x] = 0) e (v1_2 <> 1) e (v2_2 <> 1) então
                           v1_2 <- (v1_2 \ primos[x])
                           v2_2 <- (v2_2 \ primos[x])
                        fimse
                     fimenquanto
                  fimse
               fimpara

               //Caso os números resultantes sejam primos

               se (v1_2 = v2_2) e (v1_2 <> 1) então
                  resultadoD <- (resultadoD * v1_2)
                  v1_2 <- (v1_2 \ v1_2)
                  v2_2 <- (v2_2 \ v2_2)
               senao
                  v1_2 <- (v1_2 \ v1_2)
                  v2_2 <- (v2_2 \ v2_2)
               fimse

               //Exibe na tela os resultados finais

               escreval()
               escreval(" * MMC[", v1I, ",", v2I, " ]:", resultadoC)
               escreval(" * MDC[", v1I, ",", v2I, " ]:", resultadoD)
               escreval()
               escreval(" - Pressione F9 para continuar...")
               pausa

            fimse
         fimse
      fimse
   fimse
fimenquanto
fimalgoritmo

Se tiver mais alguma observação pode falar.

Simon Viegas · 31 de julho de 2018

1#

Sobre:

16 horas atrás, Lucas Da Silva Aleixo disse:

Usei a variável v1I e v2I, porque o "I" representa "Inicial", ou seja valor inicial, acho que fica mais didático assim, porque na teoria o usuário está colocando aqueles valores para serem calculados e não para aparecerem no final.

Justamente... a didática vai ocorrer em "reforçar" que o que é lido não é mexido... o dado que foi inserido é o que deve ser preservado... assim como foi feito no MDC.

Perceba:

23 horas atrás, Lucas Da Silva Aleixo disse:
      v1I <- v1
      v2I <- v2
      v1_2 <- v1
      v2_2 <- v2

A v1 e a v2 tem os valores originais... ai você fez uma cópia para ser usada em cada cálculo... No MMC usou o original (que vejo como errado), já no MDC usou a cópia... entende? "O pau que dá em Chico dá em Francisco"

Resumindo:

Deixaria o v1 e v2 intocado, pois são os dados originais. Antes de cada cálculo, copia o original e usa a cópia na conta. Basta o par v1_2 e v2_2 para ambos os cálculos.

2#

Sobre:

16 horas atrás, Lucas Da Silva Aleixo disse:

Antes desta parte do ser diferente de 1, os números passam pelo processo de contas, eles serão divididos por todos os números primos de 1 ate 100, até não serem divisíveis por nenhum deles [...]

Precede de:

16 horas atrás, Lucas Da Silva Aleixo disse:

Não tenho certeza mas...

Justamente.. daí não deveria afirmar...

Então, o trecho em negrito está incorreto pois não está dividindo por todos os primos, mas sim apenas por "todos os primos que são comuns aos números". Não é a mesma coisa!

3#

Sobre:

16 horas atrás, Lucas Da Silva Aleixo disse:

[...] até não serem divisíveis por nenhum deles, o que só ocorre com os números primos.

Errado! Todos os números "diferentes de 1", e já como só está tratando de números naturais, portanto não incluindo negativos e nem o 0, são necessariamente divisíveis por primos!!!

De um modo mais direto: todo número natural, maior que 1, tem divisores primos!!! Logo, "se ele fosse divido por todos os números primos", como sugeriu, o número resultante necessariamente seria 1 e não precisaria da verificação depois... ou seja, isso prova que a afirmação em negrito do 1# é de fato está "errada".

Como citado, o que ocorre é:

21 horas atrás, Simon Viegas disse:

[...] no contexto de sua lógica, o que está se verificando é se v1 ou v2 ainda necessitaria ser decomposto em mais outros números primos... isso vai ocorrer toda vez que "um número tiver primos que o outro não contenha"... Por sinal, isso pode ocorrer para ambos os números. Perceba que no para está justamente "retirando" o que é comum entre os 2... logo, o que vai sobrar é o que não é comum... o detalhe é que não necessariamente sobrará um único primo.

Ou seja, pode sobrar um número qualquer maior igual a 2 e que não é primo, logo, não pode dizer que está verificando se resultou em um primo.

Sobre:

16 horas atrás, Lucas Da Silva Aleixo disse:

Já que as variáveis v1 e v2 são do tipo inteiro e o VisualG só aceita 8 dígitos para variáveis de número inteiro, acho que não existe nenhum número não primo de até 8 dígitos que não seja divisível por: 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 ou que não resulte em um número primo, pois cada vez que o número vai sendo dividido, menor ele fica, e as chances de ele ser divisível por algum desses números aumentam e ai é certo que ele resultará em um número primo.

Idem! A questão não é "ser divisível por um primo", pois não está tentando fazer isso!!! O para só dividirá por primos que são comuns a ambos os números! Basta ter 2 primos não comuns ao outro que a "sobra" não será primo!!!!!

4#

16 horas atrás, Lucas Da Silva Aleixo disse:

A parte do (v1 <> 1) e (v2 <> 1) é para confirmar se a conta não acabou.

Perfeito... o "debate" está sobre o "erro da frase", ou seja, estaria sendo correto a tal confirmação, o que está errado é a justificativa!.

O código não está verificando se sobrou um primo, está verificando se sobrou algo maior que 1. O erro está em "afirmar" que esse número necessariamente é primo. (não é!)

5#

Sobre as modificações:

16 horas atrás, Lucas Da Silva Aleixo disse:

1° - Coloquei um comando enquanto v1, v2 <> 0, pois no enunciado pede um número não determinados de pares.

OK. obs.: não sou muito fã do interrompa, mas isso seria assunto para outro momento. Por ora deixe assim.

16 horas atrás, Lucas Da Silva Aleixo disse:

2° - Troquei o 25 pelo 100 novamente.

Beleza... não cheguei a uma conclusão sobre isso. Mas acho meio que tanto faz.

16 horas atrás, Lucas Da Silva Aleixo disse:

3° - Retirei a parte para verificar se o número é nulo, já que para quando o usuário digitar 0 é para sair, então a cada v1 lido, ele verifica se é igual a zero, o mesmo ocorre com o v2.

Bacana... obs.: observe que a condição do enquanto também perde o sentido, pois SEMPRE será diferente de 0. Mas pode ignorar também por enquanto.

16 horas atrás, Lucas Da Silva Aleixo disse:

4° Consertei as frases (exceto a do número primo)

Num futuro breve posto ponto a ponto sobre os detalhes do código. A postagem já está grande o suficiente.

16 horas atrás, Lucas Da Silva Aleixo disse:

5° Tirei aquela parte do (v1 % v1 = 0)

Justo! Todo natural dividido por ele mesmo tem resto 1! Para quê verificar?

17 horas atrás, Lucas Da Silva Aleixo disse:

6° Coloquei uma parte para verificar se os números são iguais, porque caso for o MMC e o MDC serão iguais aos valores. Se não tiver esta parte a conta sairá errada.

Ai vem: o que está errado é o resultado dos cálculos ou o que está errado é dizer que são iguais aos valores? precisa analisar isso.

***

Mais tarde ou a partir de amanhã vou analisar o código mais a fundo!

Att.