VisualG Exercício - Contador de 1 a 10 ou 10 a 1

Vinícius V. · 31 de outubro de 2017

Olá pessoal do CdH, podem avaliar meu código?

Agradeço mt

algoritmo "SuperContador"
// =============================================================
// Algoritmo que dá 3 opções:
//    [1] Contar de 1 até 10
//    [2] Contar de 10 até 1
//    [3] Terminar programa
// AUTOR: Vinícius V.
// 27/10/2017
// =============================================================
//Procedimentos:
procedimento MSG_QuerExecutarDenovo()
inicio
   EscrevaL("Deseja executar o programa de novo?")
   EscrevaL("Responda [S] para continuar.")
   EscrevaL("Responda com qualquer outra tecla para terminar o programa.")
   Escreva("Resposta: ")
fimprocedimento
//-------------------------
procedimento MSG_Carregando()
inicio
  EscrevaL("Carregando..")
   timer 250
   timer <off>
fimprocedimento
//-------------------------
procedimento MSG_Saindo()
inicio
   EscrevaL("Saindo..")
   timer 600
   timer <off>
fimprocedimento
//-------------------------
procedimento MSG_Opcao_Invalida()
inicio
   EscrevaL("Opção inválida")
   timer 600
   timer <off>
fimprocedimento
//-------------------------
procedimento pulalinha()
inicio
   EscrevaL()
fimprocedimento
//-------------------------
procedimento parar()
inicio
   parar <- "verdadeiro"
fimprocedimento
//-------------------------
var
   Resposta : caractere
   C, op : Inteiro
   parar : logico
inicio
Repita
   EscrevaL("-------------------------")
   EscrevaL("|     SuperContador     |")
   EscrevaL("-------------------------")
   EscrevaL("|[1] Contar de 1 ate 10 |")
   EscrevaL("|[2] Contar de 10 ate 1 |")
   EscrevaL("|[3] Sair   ---------   |")
   EscrevaL("-------------------------")
   Escreva("| Digite uma opção: ")
      Leia(op)
      Escolha op
      Caso 1, 2
         Se (op = 1) então
            C <- 1
            Repita
               Escreva(C)
               C <- C + 1
            Ate C > 10
         Fimse
         Se (op = 2) então
            C <- 10
            Repita
               Escreva(C)
               C <- C - 1
            Ate C < 1
         Fimse
            pulalinha()
            MSG_QuerExecutarDenovo()
            Leia(Resposta)
         Se Resposta = "S" então
            MSG_Carregando()
         Senao
            MSG_Saindo()
            parar()
         Fimse
      Caso 3
            MSG_Saindo()
            parar()
      OutroCaso
            MSG_Opcao_Invalida()
      FimEscolha
   LimpaTela
Ate parar
fimalgoritmo

devair1010 · 1 de novembro de 2017

@viniciusv21 seu código está bom, mas a variável parar está dando erro pois ela é igual ao nome de um procedimento, então precisa modificar ela, e o lógico não precisa colocar entre aspas . o caso 1 e 2 estava confuso então coloque eles separados, o restante está certo.

aqui seu código com algumas modificações :

algoritmo "SuperContador"
// =============================================================
// Algoritmo que dá 3 opções:
//    [1] Contar de 1 até 10
//    [2] Contar de 10 até 1
//    [3] Terminar programa
// AUTOR: Vinícius V.
// 27/10/2017
// =============================================================
//Procedimentos:
procedimento MSG_QuerExecutarDenovo()
inicio
   EscrevaL("Deseja executar o programa de novo?")
   EscrevaL("Responda [S] para continuar.")
   EscrevaL("Responda com qualquer outra tecla para terminar o programa.")
   Escreva("Resposta: ")
fimprocedimento
//-------------------------
procedimento MSG_Carregando()
inicio
  EscrevaL("Carregando..")
   timer 250
   timer <off>
fimprocedimento
//-------------------------
procedimento MSG_Saindo()
inicio
   EscrevaL("Saindo..")
   timer 600
   timer <off>
fimprocedimento
//-------------------------
procedimento MSG_Opcao_Invalida()
inicio
   EscrevaL("Opção inválida")
   timer 600
   timer <off>
fimprocedimento
//-------------------------
procedimento pulalinha()
inicio
   EscrevaL()
fimprocedimento
//-------------------------
procedimento parar()
inicio
   parar1 <- verdadeiro
fimprocedimento
//-------------------------
var
   Resposta : caractere
   C, op : Inteiro
   parar1 : logico
inicio
Repita
   EscrevaL("-------------------------")
   EscrevaL("|     SuperContador     |")
   EscrevaL("-------------------------")
   EscrevaL("|[1] Contar de 1 ate 10 |")
   EscrevaL("|[2] Contar de 10 ate 1 |")
   EscrevaL("|[3] Sair   ---------   |")
   EscrevaL("-------------------------")
   Escreva("| Digite uma opção: ")
      Leia(op)
      escolha op
      Caso 1
            C <- 1
            Repita
               Escreva(C)
               C <- C + 1
            Ate C > 10
            pulalinha()
            MSG_QuerExecutarDenovo()
            Leia(Resposta)
            Se Resposta = "S" ENTÃO
              MSG_Carregando()
            Senao
              MSG_Saindo()
              parar()
           Fimse
      caso 2
            C <- 10
            Repita
               Escreva(C)
               C <- C - 1
            Ate C < 1
            pulalinha()
            MSG_QuerExecutarDenovo()
            Leia(Resposta)
            Se Resposta = "S" ENTÃO
              MSG_Carregando()
            Senao
              MSG_Saindo()
              parar()
           Fimse
      Caso 3
            MSG_Saindo()
            parar()
      OutroCaso
            MSG_Opcao_Invalida()
      FimEscolha
   LimpaTela
Ate parar1
fimalgoritmo

Vinícius V. · 4 de novembro de 2017

Muito obrigado pela avaliação

Hoje vi que posso complementar o comando Para com passos, daí resolvi fazer um procedimento. Acredito que melhorou porque economizei umas 8 linhas no código principal , mas em contrapartida o procedimento adicionou mais 8 linhas também hehe).

Chamada:
procedimento contador(1,10,1) //Contar de 1 a 10
ou
procedimento contador(10,1,-1) // Contar de 10 a 1
//-------------
procedimento contador (inicial, final, salto: inteiro)
var 
	C : inteiro
inicio
	Para C de inicial ate final passo salto faca
		Escreva(C)
	FimPara
fimprocedimento
//--------------

Simon Viegas · 5 de novembro de 2017

Olá @viniciusv21.

Por favor, poste o seu código completo para avaliarmos melhor.

No aguardo.

Vinícius V. · 8 de novembro de 2017

algoritmo "SuperContador"
// =============================================================
// Algoritmo que dá 3 opções:
//    [1] Contar de 1 até 10
//    [2] Contar de 10 até 1
//    [3] Terminar programa
//    - Caso usuário escolha [1] ou [2] , no final vai perguntar
//    se quer executar de novo. Caso responda [S], vai limpar a tela
//    e voltar para o Menu Principal. Caso escolha outra tecla,
//    a variável PARAR receberá verdadeiro e o programa não vai repetir
//    no próximo loop.
//    - Caso Escolha [3], a variável PARAR receberá verdadeiro e no
//    próximo loop o programa não vai repetir.
//AUTOR: Vinícius V.
// 27/10/2017
// =============================================================
// AUTOR: Vinícius
// 27/10/2017
// =============================================================
//Procedimentos:

procedimento MSG_QuerExecutarDenovo()
inicio
   EscrevaL("Deseja executar o programa de novo?")
   EscrevaL("Responda [S] para continuar.")
   EscrevaL("Responda com qualquer outra tecla para terminar o programa.")
   Escreva("Resposta: ")
fimprocedimento

procedimento contador (I, F, S: inteiro)
var
	C : inteiro
inicio
	Para C de I ate F passo S faca
		Escreva(C)
	FimPara
   EscrevaL()
fimprocedimento

procedimento MSG_Carregando()
inicio
   EscrevaL("Carregando..")
   timer 250
   timer <off>
fimprocedimento

procedimento MSG_Saindo()
inicio
   EscrevaL("Saindo..")
   timer 600
   timer <off>
fimprocedimento

var
   Resposta : caractere
   C, op : Inteiro
   parar : logico
inicio
Repita
   //Menu Principal:
   EscrevaL("-------------------------")
   EscrevaL("|     SuperContador     |")
   EscrevaL("-------------------------")
   EscrevaL("|[1] Contar de 1 ate 10 |")
   EscrevaL("|[2] Contar de 10 ate 1 |")
   EscrevaL("|[3] Sair   ---------   |")
   EscrevaL("-------------------------")
   Escreva("| Digite uma opção: ")
   //---------------
      Leia(op)
      Escolha op
      Caso 1
            procedimento contador(1,10,1) //Contar de 1 a 10
        //Menu Executar de novo:
            MSG_QuerExecutarDenovo()
            Leia(Resposta)
         Se Resposta = "S" então
            MSG_Carregando()
         Senao
            MSG_Saindo()
            parar <- verdadeiro
         Fimse
        //---------------------
      Caso 2
            procedimento contador(10,1,-1) // Contar de 10 a 1
         //Menu Executar de novo:
            MSG_QuerExecutarDenovo()
            Leia(Resposta)
         Se Resposta = "S" então
            MSG_Carregando()
         Senao
            MSG_Saindo()
            parar <- verdadeiro
         Fimse
         //----------------------
      Caso 3
            MSG_Saindo()
            parar <- verdadeiro
      OutroCaso
            EscrevaL("Opção inválida")
            timer 600
            timer <off>
      FimEscolha
   LimpaTela
Ate parar = verdadeiro
fimalgoritmo

Simon Viegas · 8 de novembro de 2017

Olá @viniciusv21.

1) SINTAXE DO VISUALG

Em 04/11/2017 às 16:21, viniciusv21 disse:


procedimento contador(1,10,1) //Contar de 1 a 10
ou
procedimento contador(10,1,-1) // Contar de 10 a 1

Analisando o código, vi que está utilizando assim no corpo do programa, mas para "chamar" um procedimento ou função, não é necessário usar palavra-chave procedimento ou função... esses são só usados apenas para "declará-los" (criar lá em cima).

No caso ficaria apenas assim:

contador(1,10,1) //Contar de 1 a 10
ou
contador(10,1,-1) // Contar de 10 a 1

Apenas apague a palavra "procedimento".

2) DECLARAÇÃO DE VARIÁVEIS

A variável C (global) não está sendo usada em momento algum no código. Apenas apague-a.

obs.: a variável C lá do procedimento não tem nada a ver com essa a variável C do programa principal (na verdade tem: apenas que tem a mesma nomenclatura, mas possuem "escopos diferentes"). Não sei se foi o caso, mas para usar uma variável local, não é necessário também declarar ela como global. A variável C do procedimento só existe naquele escopo... o resto do programa não enxerga ela. Você poderia usar o mesmo nome "C" em outro procedimento e um não teria influência no outro... Entende? se tiver dúvidas, é só comentar.

3) INDENTAÇÃO DO CÓDIGO

É necessário que o código sempre esteja indentado. No Visualg ainda é mais fácil, pois o próprio programa tem um recurso de indentação. Basta acessar o menu "Editar/Indentação", ou simplesmente pressionar "Ctrt+G".

Ficaria assim:

algoritmo "SuperContador"
// =============================================================
// Algoritmo que dá 3 opções:
//    [1] Contar de 1 até 10
//    [2] Contar de 10 até 1
//    [3] Terminar programa
//    - Caso usuário escolha [1] ou [2] , no final vai perguntar
//    se quer executar de novo. Caso responda [S], vai limpar a tela
//    e voltar para o Menu Principal. Caso escolha outra tecla,
//    a variável PARAR receberá verdadeiro e o programa não vai repetir
//    no próximo loop.
//    - Caso Escolha [3], a variável PARAR receberá verdadeiro e no
//    próximo loop o programa não vai repetir.
//AUTOR: Vinícius V.
// 27/10/2017
// =============================================================
// AUTOR: Vinícius
// 27/10/2017
// =============================================================
//Procedimentos:

procedimento MSG_QuerExecutarDenovo()
inicio
   EscrevaL("Deseja executar o programa de novo?")
   EscrevaL("Responda [S] para continuar.")
   EscrevaL("Responda com qualquer outra tecla para terminar o programa.")
   Escreva("Resposta: ")
fimprocedimento

procedimento contador (I, F, S: inteiro)
var
   C : inteiro
inicio
   Para C de I ate F passo S faca
      Escreva(C)
   FimPara
   EscrevaL()
fimprocedimento

procedimento MSG_Carregando()
inicio
   EscrevaL("Carregando..")
   timer 500
   timer <off>
fimprocedimento

procedimento MSG_Saindo()
inicio
   EscrevaL("Saindo..")
   timer 600
   timer <off>
fimprocedimento

var
   Resposta : caractere
   C, op : Inteiro
   parar : logico
inicio
   Repita
      //Menu Principal:
      EscrevaL("-------------------------")
      EscrevaL("|     SuperContador     |")
      EscrevaL("-------------------------")
      EscrevaL("|[1] Contar de 1 ate 10 |")
      EscrevaL("|[2] Contar de 10 ate 1 |")
      EscrevaL("|[3] Sair   ---------   |")
      EscrevaL("-------------------------")
      Escreva("| Digite uma opção: ")
      //---------------
      Leia(op)
      Escolha op
      Caso 1
         contador(1,10,1) //Contar de 1 a 10
         //Menu Executar de novo:
         MSG_QuerExecutarDenovo()
         Leia(Resposta)
         Se Resposta = "S" ENTÃO
            MSG_Carregando()
         Senao
            MSG_Saindo()
            parar <- verdadeiro
         Fimse
         //---------------------
      Caso 2
         contador(10,1,-1) // Contar de 10 a 1
         //Menu Executar de novo:
         MSG_QuerExecutarDenovo()
         Leia(Resposta)
         Se Resposta = "S" ENTÃO
            MSG_Carregando()
         Senao
            MSG_Saindo()
            parar <- verdadeiro
         Fimse
         //----------------------
      Caso 3
         MSG_Saindo()
         parar <- verdadeiro
      OutroCaso
         EscrevaL("Opção inválida")
         timer 600
         timer <off>
      FimEscolha
      LimpaTela
   Ate parar = verdadeiro
fimalgoritmo

Você não é obrigado a seguir o "padrão" do Visualg... se fosse usar o "meu", ficaria assim:

algoritmo "SuperContador"
// =============================================================
// Algoritmo que dá 3 opções:
//    [1] Contar de 1 até 10
//    [2] Contar de 10 até 1
//    [3] Terminar programa
//    - Caso usuário escolha [1] ou [2] , no final vai perguntar
//    se quer executar de novo. Caso responda [S], vai limpar a tela
//    e voltar para o Menu Principal. Caso escolha outra tecla,
//    a variável PARAR receberá verdadeiro e o programa não vai repetir
//    no próximo loop.
//    - Caso Escolha [3], a variável PARAR receberá verdadeiro e no
//    próximo loop o programa não vai repetir.
//AUTOR: Vinícius V.
// 27/10/2017
// =============================================================
// AUTOR: Vinícius
// 27/10/2017
// =============================================================
//Procedimentos:

procedimento MSG_QuerExecutarDenovo()
   inicio
   EscrevaL("Deseja executar o programa de novo?")
   EscrevaL("Responda [S] para continuar.")
   EscrevaL("Responda com qualquer outra tecla para terminar o programa.")
   Escreva ("Resposta: ")
   fimprocedimento

procedimento contador (I, F, S: inteiro)
   var
      C : inteiro
   inicio
   Para C de I ate F passo S faca
      Escreva (C)
   FimPara
   EscrevaL()
   fimprocedimento

procedimento MSG_Carregando()
   inicio
   EscrevaL("Carregando..")
   timer 500
   timer <off>
   fimprocedimento

procedimento MSG_Saindo()
   inicio
   EscrevaL("Saindo..")
   timer 600
   timer <off>
   fimprocedimento

var
   Resposta : caractere
   C, op : Inteiro
   parar : logico
inicio
Repita
   //Menu Principal:
   EscrevaL("-------------------------")
   EscrevaL("|     SuperContador     |")
   EscrevaL("-------------------------")
   EscrevaL("|[1] Contar de 1 ate 10 |")
   EscrevaL("|[2] Contar de 10 ate 1 |")
   EscrevaL("|[3] Sair   ---------   |")
   EscrevaL("-------------------------")
   Escreva ("| Digite uma opção: ")
   //---------------
   Leia(op)
   Escolha op
      Caso 1
         contador(1,10,1) //Contar de 1 a 10
         //Menu Executar de novo:
         MSG_QuerExecutarDenovo()
         Leia(Resposta)
         Se Resposta = "S" ENTÃO
            MSG_Carregando()
         Senao
            MSG_Saindo()
            parar <- verdadeiro
         Fimse
         //---------------------
      Caso 2
         contador(10,1,-1) // Contar de 10 a 1
         //Menu Executar de novo:
         MSG_QuerExecutarDenovo()
         Leia(Resposta)
         Se Resposta = "S" ENTÃO
            MSG_Carregando()
         Senao
            MSG_Saindo()
            parar <- verdadeiro
         Fimse
         //----------------------
      Caso 3
         MSG_Saindo()
         parar <- verdadeiro
      OutroCaso
         EscrevaL("Opção inválida")
         timer 600
         timer <off>
   FimEscolha
   LimpaTela
Ate parar = verdadeiro
fimalgoritmo

Tem algumas pequenas diferenças.

PS: experimente usar o Ctrl+G com seu código da postagem anterior (que está chamando o procedimento com o termo "procedimento") e veja o que acontece.

***

No aguardo.

Vinícius V. · 19 de novembro de 2017

Obrigado pelo comentário.

Em 08/11/2017 às 10:34, Simon Viegas disse:
Olá @viniciusv21.

1) SINTAXE DO VISUALG

Analisando o código, vi que está utilizando assim no corpo do programa, mas para "chamar" um procedimento ou função, não é necessário usar palavra-chave procedimento ou função... esses são só usados apenas para "declará-los" (criar lá em cima).

No caso ficaria apenas assim:
contador(1,10,1) //Contar de 1 a 10
ou
contador(10,1,-1) // Contar de 10 a 1

Falta de atenção mesmo rs

Em 08/11/2017 às 10:34, Simon Viegas disse:

2) DECLARAÇÃO DE VARIÁVEIS

A variável C (global) não está sendo usada em momento algum no código. Apenas apague-a.

obs.: a variável C lá do procedimento não tem nada a ver com essa a variável C do programa principal (na verdade tem: apenas que tem a mesma nomenclatura, mas possuem "escopos diferentes"). Não sei se foi o caso, mas para usar uma variável local, não é necessário também declarar ela como global. A variável C do procedimento só existe naquele escopo... o resto do programa não enxerga ela. Você poderia usar o mesmo nome "C" em outro procedimento e um não teria influência no outro... Entende? se tiver dúvidas, é só comentar.

Eu sabia, só esqueci de tirar .

Naquela vez que indentei tentei usar um código que vi na Internet em que se alinhava o código pelas funções. Por exemplo, colocar "escreva" todos alinhados. Mas vi agora que não ficou muito bom.. Segue o código agora:

algoritmo "SuperContador"
// =============================================================
// Algoritmo que dá 3 opções:
//    [1] Contar de 1 até 10
//    [2] Contar de 10 até 1
//    [3] Terminar programa
//    - Caso usuário escolha [1] ou [2] , no final vai perguntar
//    se quer executar de novo. Caso responda [S], vai limpar a tela
//    e voltar para o Menu Principal. Caso escolha outra tecla,
//    a variável PARAR receberá verdadeiro e o programa não vai repetir
//    no próximo loop.
//    - Caso Escolha [3], a variável PARAR receberá verdadeiro e no
//    próximo loop o programa não vai repetir.
// =============================================================
// AUTOR: Vinícius V.
// 18/11/2017
// =============================================================
//Procedimentos:

procedimento MSG_QuerExecutarDenovo()
inicio
   EscrevaL("Deseja executar o programa de novo?")
   EscrevaL("Responda [S] para continuar.")
   EscrevaL("Responda com qualquer outra tecla para terminar o programa.")
   Escreva("Resposta: ")
fimprocedimento

procedimento contador (I, F, S: inteiro)
var
   C : inteiro
inicio
   Para C de I ate F passo S faca
      Escreva(C)
   FimPara
   EscrevaL()
fimprocedimento

procedimento MSG_Carregando()
inicio
   EscrevaL("Carregando..")
   timer 250
   timer <off>
fimprocedimento

procedimento MSG_Saindo()
inicio
   EscrevaL("Saindo..")
   timer 600
   timer <off>
fimprocedimento

var
   Resposta : caractere
   op : Inteiro
   parar : logico
inicio
Repita
   //Menu Principal:
   EscrevaL("-------------------------")
   EscrevaL("|     SuperContador     |")
   EscrevaL("-------------------------")
   EscrevaL("|[1] Contar de 1 ate 10 |")
   EscrevaL("|[2] Contar de 10 ate 1 |")
   EscrevaL("|[3] Sair   ---------   |")
   EscrevaL("-------------------------")
   Escreva("| Digite uma opção: ")
   //---------------
   Leia(op)
   Escolha op
      Caso 1
         contador(1,10,1) //Contar de 1 a 10
         //Menu Executar de novo:
         MSG_QuerExecutarDenovo()
         Leia(Resposta)
         Se Resposta = "S" então
            MSG_Carregando()
         Senao
            MSG_Saindo()
            parar <- verdadeiro
         Fimse
         //---------------------
      Caso 2
         contador(1,10,-1) //Contar de 10 a 1
         //Menu Executar de novo:
         MSG_QuerExecutarDenovo()
         Leia(Resposta)
         Se Resposta = "S" então
            MSG_Carregando()
         Senao
            MSG_Saindo()
            parar <- verdadeiro
         Fimse
         //----------------------
      Caso 3
         MSG_Saindo()
         parar <- verdadeiro
      OutroCaso
         EscrevaL("Opção inválida")
         timer 600
         timer <off>
      FimEscolha
   LimpaTela
Ate parar = verdadeiro
fimalgoritmo

Simon Viegas · 20 de novembro de 2017

Olá @viniciusv21. Ficou TOP.

Se tiver alguma dúvida sobre o código ou queria implementar algo mais, é só avisar. Caso contrário, favor sinalizar para darmos o tópico como resolvido.

ADENDO:

Em relação a minha indentação anterior, apenas esqueci de aplicar outro conceito que gosto. Ex.:

procedimento MSG_QuerExecutarDenovo()
   inicio
   EscrevaL("Deseja executar o programa de novo?")
   EscrevaL("Responda [S] para continuar.")
   EscrevaL("Responda com qualquer outra tecla para terminar o programa.")
   Escreva ("Resposta: ")
   fimprocedimento

Observe que dei um espaço no escreva, desta fora, a parte do texto fica alinhada.

PS: eu editei a minha postagem para inserir esse conceito.

No aguardo.

Vinícius V. · 25 de dezembro de 2017

Em 20/11/2017 às 10:09, Simon Viegas disse:
ADENDO:

Em relação a minha indentação anterior, apenas esqueci de aplicar outro conceito que gosto. Ex.:
procedimento MSG_QuerExecutarDenovo()
   inicio
   EscrevaL("Deseja executar o programa de novo?")
   EscrevaL("Responda [S] para continuar.")
   EscrevaL("Responda com qualquer outra tecla para terminar o programa.")
   Escreva ("Resposta: ")
   fimprocedimento
Observe que dei um espaço no escreva, desta fora, a parte do texto fica alinhada.