Ir ao conteúdo
  • Comunicados

    • Gabriel Torres

      Seja um moderador do Clube do Hardware!   12-02-2016

      Prezados membros do Clube do Hardware, Está aberto o processo de seleção de novos moderadores para diversos setores ou áreas do Clube do Hardware. Os requisitos são:   Pelo menos 500 posts e um ano de cadastro; Boa frequência de participação; Ser respeitoso, cordial e educado com os demais membros; Ter bom nível de português; Ter razoável conhecimento da área em que pretende atuar; Saber trabalhar em equipe (com os moderadores, coordenadores e administradores).   Os interessados deverão enviar uma mensagem privada para o usuário @Equipe Clube do Hardware com o título "Candidato a moderador". A mensagem deverá conter respostas às perguntas abaixo:   Qual o seu nome completo? Qual sua data de nascimento? Qual sua formação/profissão? Já atuou como moderador em algo outro fórum, se sim, qual? De forma sucinta, explique o porquê de querer ser moderador do fórum e conte-nos um pouco sobre você.   OBS: Não se trata de função remunerada. Todos que fazem parte do staff são voluntários.
    • DiF

      Poste seus códigos corretamente!   21-05-2016

      Prezados membros do Fórum do Clube do Hardware, O Fórum oferece um recurso chamado CODE, onde o ícone no painel do editor é  <>     O uso deste recurso é  imprescindível para uma melhor leitura, manter a organização, diferenciar de texto comum e principalmente evitar que os compiladores e IDEs acusem erro ao colar um código copiado daqui. Portanto convido-lhes para ler as instruções de como usar este recurso CODE neste tópico:  
viniciusv21

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

Recommended Posts

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

 

Editado por Simon Viegas
Alterado tag CODE para "C Languages"
  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

@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

 

Compartilhar este post


Link para o post
Compartilhar em outros sites
  • Autor do tópico
  • 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
    //--------------

     

    • Curtir 2

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites
  • Autor do tópico
  • 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

     

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites

    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.

    Editado por Simon Viegas
    Pequeno ajuste na minha indentação (dar um espaço após o Escreva).
    • Curtir 1

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites
  • Autor do tópico
  • 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

     

    Editado por DiF
    Remover citação gigante do código
    • Curtir 1

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites

    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.

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites

    Crie uma conta ou entre para comentar

    Você precisar ser um membro para fazer um comentário






    Sobre o Clube do Hardware

    No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

    Direitos autorais

    Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

    ×