VisualG Resolução de um exercício e esclarecimentos

[xisxisde]

Então, neste tópico há duas coisas: a resolução de um problema e algumas duvidas, finalizei meu estudo de algoritmos, mas tenho algumas duvidas, uma muito pertinente que quero encontrar a solução logo, vamos lá, primeiro as duvidas:

Qual a diferença entre projeto logico e físico?
Como usar uma variável boolean eficientemente (se puder dar exemplos, de (S/N) com algoritmos seria ótimo) ?
Quais são os comandos de input das teclas do teclado, e do mouse para algoritmos, se existem, por exemplo eu quero apertar a tecla enter depois de escrever (S/N)? ... (sim eu sei que no dos você aperta o enter mas eu gostaria de ter esta pergunta respondida)

Agora vamos ao problema que eu "resolvi", o resultado no VisualG e o DOS todo em negrito, se eu apertar enter muitas vezes ele da erro em uma das linhas ...

O problema: 
 

Escreva um algoritmo para ler dois valores. Após a leitura deve-se calcular a soma dos valores lidos e armazená-la em uma variável. Após o cálculo da soma, escrever o resultado e escrever também a pergunta 'Novo Cálculo (S/N)?'. Deve-se ler a resposta e se a resposta for 'S' (sim), deve-se repetir todos os comandos (instruções) novamente, mas se a resposta for 'N' (não), o algoritmo deve ser finalizado escrevendo a mensagem 'Fim dos Cálculos'.

 

 

PS: Sobre este problema, se alguém conseguir fazer um algoritmo para o VisualG que escreva "Novo calculo (S/N)?" e você aperte a tecla S ou N e de enter e tal por favor, é isso que estou tentando e procurando, além das outras duvidas...

 

A solução no VisualG:

algoritmo "sem nome"
// Descrição   : Aqui você descreve o que o programa faz! (função)
// Autor(a)    : Nome do(a) aluno(a)
// Data atual  : 21/06/2021
var
   A: inteiro
   B: inteiro
   C: inteiro
   S: logico
   N: logico
inicio
   A <- 10
   B <- 20

   leia(A)
   leia(B)
   leia(A)+(B) = (C)
   leia(C)
   escreval("Novo Calculo (S/N)?")
   leia(S) ou (N)
   se (S)
   fimse
   enquanto (A+B = 30) faca
      (A)+(B) = 30
   fimenquanto
   se (N)
      escreval ("Fim dos calculos")
   fimse

 

[devair1010]

@xisxisde    Creio lógico seja algo intuitivo e fisico que é real e se pode tocar , não se pode ler uma variável boleana do teclado , então use uma do tipo caractere para fazer a leitura e depois compare com as letras s  e  n  , e sendo s atribua a variável o valor verdadeiro e se for n o valor falso , e para repetir você pode usar o repita , e faça a identação do código , pois facilita a detecção de erros ,  e seu código poderia ser assim  :

Algoritmo "boolean"
// Data atual  : 21/06/2021
Var
  a,b       : real
  opcao     : caractere
  resultado : real
  resp      : logico
Inicio
  resp <- verdadeiro // logico só pode ter esses dois valores (verdadeiro  falso)
    
  repita             // para repetir novamente
    limpatela        // limpara a tela
    escreva("informe um número ")// msg informativa
    leia(a)                     // ler número
    escreva("informe outro número ") // msg
    leia(b)                     // ler numero
    resultado <- a + b  // aqui faz e armazena o calculo
    escreval("o resultado é : ",resultado) // mostra o resultado
    escreval                    // pula para a linha de baixo
    escreva("Novo Calculo ( S / N ) ") // msg se quer repetir ou não
    leia(opcao)                 // ler o teclado
    se opcao = "n" entao        // compare com a letra n ou N
      resp := falso             // marca como falso
    fimse                       // termina a comparação
  ate resp = falso              // repete esse bloco até resp igual a falso
        
  escreval                      // pula a linha para baixo
  escreval("Fim dos calculos . . . !")  // mostra a msg fim dos calculos !
  escreval                      // pula a linha para baixo
  escreval                      // pula a linha para baixo
fimalgoritmo

 

[xisxisde]

@devair1010 

Citação

eu dei edit entendi tudo que você postou

 

 

muito obrigado, vou estudar este algoritmo que você postou

[xisxisde]

Então, @devair1010, deixa eu te citar de novo só pra você vim aqui, eu ainda estou tentando resolver este exercício com enquanto faça, se alguém quiser pegar da onde eu parei, está dando erro na linha c = "falso" porque o loop não está ocorrendo, acho que é preciso de mais alguns comandos só não sei quais, sinceramente, não sei porque o loop não acontece, mas não vou pedir mais ajuda vou tentar resolver sozinho, talvez na expressão logica um ou ou e ou xou sei la, vou deixar o código do enquanto faça da onde eu parei aqui pra quem precisar:
 

algoritmo "não entendi nada"
// Descrição   : Aqui você descreve o que o programa faz! (função)
// Autor(a)    : Nome do(a) aluno(a)
// Data atual  : 22/06/2021
var
   a: real
   b: real
   c: logico
   opcao: caractere
   resultado: real

inicio
   enquanto (c = "verdadeiro") faca
      escreva ("Informe um numero:")
      leia(a)
      escreva ("Informe um numero:")
      leia(b)
      resultado <- a+b
      escreval("O resultado é:",resultado)
      escreva ("Novo calculo (S/N)?")
      leia(opcao)
      se opcao = "n" entao
         c = "falso"
      fimse
      leia(opcao)
      se opcao = "s" entao
         c = "verdadeiro"
      fimse
   fimenquanto

Eu sei que é quase tudo como você fez, mas eu criei do nada só algumas coisas que eu copiei, as básicas então, ainda não sei porque o loop não acontece mas tudo bem...

 

[devair1010]

@xisxisde    o loop nao  acontece por que voce nao inicializou a variavel  c , com o valor " verdadeiro " , logo no inicio antes do" enquanto " ,  e por tanto nao precisa comparar duas vezes a variavel  "opcao" , nao , apenas uma , e se eh falso .

[xisxisde]

Opa valeu cara agora a duvida foi esclarecida totalmente, obrigado.

[xisxisde]

Então @devair1010o loop ja esta acontecendo, é que eu estava escrevendo uma tecla e apertando enter, depois de escrever S e dar enter, dar enter de novo, o loop acontece, so pra esclarecer e obrigado por tudo.

[Simon Viegas]

Em 22/06/2021 às 16:14, devair1010 disse:

@xisxisde    o loop não  acontece por que voce não inicializou a variavel  c , com o valor " verdadeiro " , logo no inicio antes do" enquanto " 

 

Na verdade não... o problema é que a variável C foi declarada com o tipo LOGICO, mas no enquanto está tentando comparar com um conjunto de CARACTERES:

 

 

 Não dá para comparar um tipo logico com um tipo caractere, ou seja: são tipos incompatíveis entre si. (Era para dar erro, mas o VisualG tem alguns bugs )

 

O erro principal está no uso dessas aspas duplas... o correto seria algo assim:

 

 

 

 

Para eu ser mais objetivo, segue uns exemplos:

 

1.0 VERSÂO SIMPLES DE UMA SOMA (sem repetições)

algoritmo "Exercício de repetição"
//Escreva um algoritmo para ler dois valores. Após a leitura deve-se calcular
//a soma dos valores lidos e armazená-la em uma variável. Após o cálculo da
//soma, escrever o resultado e escrever também a pergunta 'Novo Cálculo (S/N)?'.
//Deve-se ler a resposta e se a resposta for 'S' (sim), deve-se repetir todos
//os comandos (instruções) novamente, mas se a resposta for 'N' (não), o
// algoritmo deve ser finalizado escrevendo a mensagem 'Fim dos Cálculos'.

var
   a: real
   b: real
   soma: real

inicio
escreval("Informe o primeiro valor: ")
leia(a)
escreval("Informe o segundo valor: ")
leia(b)
soma <- a + b
escreval("Resultado da somas dos valores:", soma)
fimAlgoritmo

 

 

2.1 VERSÃO DE SOMAS COM REPETIÇÃO (enquanto)

algoritmo "Exercício de repetição"
//Escreva um algoritmo para ler dois valores. Após a leitura deve-se calcular
//a soma dos valores lidos e armazená-la em uma variável. Após o cálculo da
//soma, escrever o resultado e escrever também a pergunta 'Novo Cálculo (S/N)?'.
//Deve-se ler a resposta e se a resposta for 'S' (sim), deve-se repetir todos
//os comandos (instruções) novamente, mas se a resposta for 'N' (não), o
// algoritmo deve ser finalizado escrevendo a mensagem 'Fim dos Cálculos'.

var
   a: real
   b: real
   soma: real
   resp: caractere

inicio
   enquanto (resp <> "N") faca
      escreval("Informe o primeiro valor: ")
      leia(a)
      escreval("Informe o segundo valor: ")
      leia(b)
      soma <- a + b
      escreval("Resultado da somas dos valores:", soma)
      escreval("Novo Cálculo (S/N)?")
      leia(resp)
   fimEnquanto
   escreval("Fim dos Cálculos")
fimAlgoritmo

 

 

2.2 VERSÃO DE SOMAS COM REPETIÇÃO (repita)

algoritmo "Exercício de repetição"
//Escreva um algoritmo para ler dois valores. Após a leitura deve-se calcular
//a soma dos valores lidos e armazená-la em uma variável. Após o cálculo da
//soma, escrever o resultado e escrever também a pergunta 'Novo Cálculo (S/N)?'.
//Deve-se ler a resposta e se a resposta for 'S' (sim), deve-se repetir todos
//os comandos (instruções) novamente, mas se a resposta for 'N' (não), o
// algoritmo deve ser finalizado escrevendo a mensagem 'Fim dos Cálculos'.

var
   a: real
   b: real
   soma: real
   resp: caractere

inicio
   repita
      escreval("Informe o primeiro valor: ")
      leia(a)
      escreval("Informe o segundo valor: ")
      leia(b)
      soma <- a + b
      escreval("Resultado da somas dos valores:", soma)
      escreval("Novo Cálculo (S/N)?")
      leia(resp)
   ate resp = "N"
   escreval("Fim dos Cálculos")
fimAlgoritmo

 

Adendo: usar enquanto ou repita vai de acordo com o gosto ou praticidade... tudo que faz com um, dá para fazer com um outro...

 

 

Daí, caso queira implementar usando uma variável lógica, poderia ser como sugerido pelo @devair1010:

 

 

Ou seja: nos meus exemplos, o resp está declarado como caractere, daí eu fiz comparações com caracteres mesmo (caractere x caractere). Lá diretamente no enquanto... já declarando o resp como logico no exemplo acima, a comparação está sendo feita com um valor lógico (lógico x lógico), ou seja: primeiro foi necessário utilizar um se para verificar se foi informado um "n" (que é um caractere... - não dá para enviar um direto lógico do teclado), daí "insere o valor FALSO" na variável (esse valor NÃO é um caractere), que posteriormente vai ser comparada lá no enquanto.

 

Segue um exemplo:

algoritmo "Exercício de repetição"
//Escreva um algoritmo para ler dois valores. Após a leitura deve-se calcular
//a soma dos valores lidos e armazená-la em uma variável. Após o cálculo da
//soma, escrever o resultado e escrever também a pergunta 'Novo Cálculo (S/N)?'.
//Deve-se ler a resposta e se a resposta for 'S' (sim), deve-se repetir todos
//os comandos (instruções) novamente, mas se a resposta for 'N' (não), o
// algoritmo deve ser finalizado escrevendo a mensagem 'Fim dos Cálculos'.

var
   a: real
   b: real
   resultado: real
   opcao: caractere
   continuar: logico

inicio
   continuar <- VERDADEIRO
   enquanto (continuar = VERDADEIRO) faca
      escreva ("Informe um numero:")
      leia(a)
      escreva ("Informe um numero:")
      leia(b)
      resultado <- a+b
      escreval("O resultado é:", resultado)
      escreva ("Novo calculo (S/N)?")
      leia(opcao)
      se opcao = "n" entao
         continuar <- FALSO
      fimSe
   fimEnquanto
fimAlgoritmo

 

Adendo: observe que não precisa verificar se digitou "s", pois da forma que foi implementado, a variável continuar vai ficar com VERDADEIRO até que digite um "n".

 

O comando enquanto funciona assim: se o que estiver entre o enquanto e o faca equivaler a VERDADEIRO, o enquanto vai executar mais uma vez. Mas se equivaler a FALSO, o enquanto vai parar e o programa continuará a partir da próxima linha após o fimEnquanto correspondente.

 

 

 

Então, a própria variável lógica já resulta em VERDADEIRO ou FALSO, né? Então poderia ficar assim:

 

 

Segue exemplo num código:

 

algoritmo "Exercício de repetição"
//Escreva um algoritmo para ler dois valores. Após a leitura deve-se calcular
//a soma dos valores lidos e armazená-la em uma variável. Após o cálculo da
//soma, escrever o resultado e escrever também a pergunta 'Novo Cálculo (S/N)?'.
//Deve-se ler a resposta e se a resposta for 'S' (sim), deve-se repetir todos
//os comandos (instruções) novamente, mas se a resposta for 'N' (não), o
// algoritmo deve ser finalizado escrevendo a mensagem 'Fim dos Cálculos'.

var
   a: real
   b: real
   resultado: real
   opcao: caractere
   continuar: logico

inicio
   continuar <- VERDADEIRO
   enquanto (continuar) faca
      escreva ("Informe um numero:")
      leia(a)
      escreva ("Informe um numero:")
      leia(b)
      resultado <- a+b
      escreval("O resultado é:", resultado)
      escreva ("Novo calculo (S/N)?")
      leia(opcao)
      se opcao = "n" entao
         continuar <- FALSO
      fimSe
   fimEnquanto
fimAlgoritmo