VisualG VisualG - exercício pilhas - FILO

joshuayuuki · 24 de março de 2021

Estou travado nesse exercício proposto pelo meu professor.

Sabendo da importância das estruturas de dados e como manipulá-las, você deverá implementar no VISUALG a estrutura de Pilha, lembrando que este tipo de estrutura segue o conceito de que o primeiro a entrar será o último a sair (FILO – First in Last Out). A Pilha deverá ser implementada utilizando uma estrutura homogênea com 20 posições e as seguintes funções deverão ser implementadas para a manipulação da pilha:

Empilhar (adiciona um elemento no topo da pilha);

Desempilhar (remove e retorna um elemento do topo da pilha);

Limpar (remove todos os elementos da pilha);

Listar (lista todos os elementos armazenados na pilha);

Vazia (retorna verdadeiro se a pilha estiver vazia, e falso caso contrário).

Obs. : Lembre-se de realizar todos os tratamentos necessários para que não aconteça o estouro da estrutura homogênea.

Desde de já agradeço!

Algoritmo "pilhas"

procedimento Inicializar
inicio
   topo <- 0
fimprocedimento

funcao PilhaVazia : logico
inicio
   se topo = 0 entao
      retorne verdadeiro
   senao
      retorne falso
   fimse
fimfuncao

funcao PilhaCheia : logico
inicio
   se topo = 4 entao
      retorne verdadeiro
   senao
      retorne falso
   fimse
fimfuncao

funcao Empilhar(elemento : inteiro) : logico
inicio
   se PilhaCheia entao
      retorne falso
   senao
      topo <- topo + 1
      pilha[topo] <- elemento
      retorne verdadeiro
   fimse
fimfuncao

funcao Desempilhar : inteiro
inicio
   se PilhaVazia entao
      retorne -999
   senao
      elemento <- pilha[topo]
      pilha[topo] <- 0
      topo <- topo - 1
      retorne elemento
   fimse
fimfuncao

Var
   pilha : vetor[1..4] de inteiro
   topo : inteiro
   elemento : inteiro
   valor : inteiro
   i : inteiro
   comando : caracter
   qtd, x : inteiro

Inicio
   qtd <- 0
   x <- 0
   Inicializar
   escreval("Bem vindo ao programa das Pilhas - FIFO ")
   escreval("---------------------------------------------")
   escreval("(E) para Empilhar         | (D) para desempilhar")
   escreval("(T) para imprimir o Topo  | (R) para imprimir o Resultado dos itens desempilhados")
   escreval("     (X) para Encerrar e imprimir a qtd de itens empilhados")
   escreval("---------------------------------------------")
   escreval("")
   leia(comando)
   enquanto ((comando <> "x") ou (comando <> "X")) faca
      se comando = "E" entao
         se PilhaCheia entao
            escreval("Pilha cheia")
         senao
            escreva("Digite o valor: ")
            leia(valor)
            se Empilhar(valor) entao
               qtd <- (qtd + 1)
               escreval("Valor empilhado!")
               escreval("")
            fimse
         fimse
      fimse


      se comando = "D" entao
         se PilhaVazia entao
            escreval("Pilha vazia")
         senao
            valor <- Desempilhar
            x <- valor
            qtd <- (qtd - 1)
            escreval("Valor desempilhado: ", valor)
            escreval("")
         fimse
      fimse

      se comando = "T" entao
         se PilhaVazia entao
            escreval("Pilha vazia")
         senao
            escreval("Topo: ", pilha[topo])
         fimse
      fimse


      se comando = "R" entao
         escreval("o Resultado dos Itens Desempilhados São: ")
         para i de 4 ate 1 passo -1 faca
            escreval(pilha[i])
         fimpara
         escreval("Valor desempilhado: ", x)
         escreval("")
      fimse

      se comando = "X" entao
         escreval("o Resultado dos Itens Desempilhados São: ")
         para i de 4 ate 1 passo -1 faca
            escreval(pilha[i])
         fimpara
         escreval("Valor desempilhado: ", x)
         escreval("")
         FIMALGORITMO
      fimse

      escreval("-------------------------------------------------")
      escreval("(E) para Empilhar         | (D) para desempilhar")
      escreval("(T) para imprimir o Topo  | (R) para imprimir o Resultado dos itens desempilhados")
      escreval("(X) para Encerrar e imprimir a qtd de itens empilhados")
      escreval("-------------------------------------------------")
      escreval("")
      leia(comando)
   fimenquanto

   se topo = 0 entao
      topo = 1
   fimse

   escreval("Pilha")
   para i de 4 ate 1 passo -1 faca
      escreval(pilha[i])
      //qtd := elemento
   fimpara

   escreval("A quantidade de intens empilhados é de : ", qtd)
Fimalgoritmo

devair1010 · 25 de março de 2021

@joshuayuuki @joshuayuuki seu código está bem desorganizado , geralmente se colocam as variáveis no início e logo abaixo das variáveis os procedimentos e funções , e depois o início da função principal , e em um código com muitas opções assim , e melhor ir fazendo aos pouco e testando , então faça a função de empilhar e a de listar e teste até que esteja certo e depois faça outras .

Simon Viegas · 25 de março de 2021

Sobre:

13 horas atrás, devair1010 disse:

@joshuayuuki, seu código está bem desorganizado, geralmente se colocam as variáveis no início [...]

@devair1010, creio que não tenha problema fazer isso... Vai funcionar normalmente e sem erros lógicos (eu acho, rs).

Um pouco mais sobre:

Spoiler

No Pascal, "pai do VisualG", poderia declarar assim após as funções para evitar usar uma variável global sem querer dentro de uma função ou procedimento (seria uma estratégia). Aqui no VisualG, também seria permitido fazer isso, mas sem essa "funcionalidade" de evitar o "mal uso das variáveis globais". Isso provavelmente acontece devido as "limitações do VisualG". É uma ferramenta mais simples... nela não é possível, por exemplo, passar um vetor por parâmetro (no Pascal pode)... daí provavelmente o "autor do projeto" resolveu continuar permitindo aceitar declarar as variáveis abaixo e ao mesmo tempo deixando o programa funcionar de alguma forma. (No Pascal iria dar erro, pois a função não iria reconhecer as variáveis - esse seria o comportamento mais coerente. Já que o Pascal e VisualG aprendem de cima para baixo.)

Em fim. Eu acredito que não tem problema declarar em baixo. Eu até prefiro assim. Fica mais próximo do programa principal (entre o inicio e fimAlgoritmo)

@joshuayuuki, sobre:

23 horas atrás, joshuayuuki disse:

Estou travado nesse exercício proposto pelo meu professor.

Tá! Mas está travado em qual ponto? Qual a sua dificuldade? Está dando algum erro ou alguma parte não está funcionando?

Fazendo uma analogia... seria como chegar com um carro numa oficina e dizer pro mecânico: "Meu carro está com problema. Tome aqui a chave". Entende?

Para tentar adiantar... ainda fazendo uma analogia, vou passar um scanner para ver se acho algo:

Vamos lá:

Um probleminha que já encontrei seria esse:

Esse comando não deveria servir para esse propósito de "finalizar o programa na marra"... Entendo que o programa deveria seguir o seu fluxo natural. O programa não dá erro simplesmente porque o VisualG é problemático .

Além do mais a estrutura do código já está correta... basta apagar essa linha!!!

Veja:

Observe que, ao utilizar o "fimEnquanto" o programa "estoura" na hora... logo, essa condição acima nunca seria verificada, o que por si só não faz sentido. (Acaba se tornando uma tautologia para o contexto - sempre o resultado será verdadeiro.)

Ah! a expressão aí no enquanto vai funcionar de boa, mas mesmo assim ela está ERRADA. Deveria ser E no lugar do OU.

ADENDO: a não ser que tenha alguma literatura ou alguém com algum argumento mais plausível, esse comando fimAlgoritmo só deveria ser usando uma vez no programa.

Um outro problema é na hora de listar... o código está exibindo todo o vetor*, mas acho que deveria exibir apenas os elementos cadastrados, ou seja: se cadastrou 2, só deveria aparecer 2 valores e não os 2 mais 0 e 0.

*vetor = nome mais simples para a tal da "estrutura homogênea"

joshuayuuki · 25 de março de 2021

@Simon Viegas Acho que dessa forma ficou bem mais claro!

Em questão de dificuldade, seria referente a materia de pilha ao todo, pois ainda é muito novo para mim.

já a hora de listar, como posso apresentar todos os elementos cadastrados?

Muito obrigado pela ajuda!

devair1010 · 25 de março de 2021

@joshuayuuki você usa um loop para começando de zero e indo até o topo e escreve o que tem no vetor .pilha .

joshuayuuki · 25 de março de 2021

@devair1010 com a função se?

devair1010 · 25 de março de 2021

@joshuayuuki não precisa compara , apenas Listar o que tem na pilha ,

Algoritmo "pilhas_FIFO"
Var
  pilha            : vetor[1..20] de inteiro
  elemento,valor,i : inteiro
  comando          : caracter
  qtd, x,topo      : inteiro
procedimento listar_tudo
inicio
  escreval("Listando a Pilha")
  para i de 1 ate topo faca
    escreval(i,"º Elento da Pilha =",pilha[i])
  fimpara
  escreval
  escreval
fimprocedimento
procedimento Inicializar
inicio
  topo <- 0
fimprocedimento

funcao PilhaVazia : logico
inicio
  se topo = 0 entao
    retorne verdadeiro
  senao
    retorne falso
  fimse
fimfuncao

funcao PilhaCheia : logico
inicio
  se topo > 20 entao
    retorne verdadeiro
  senao
    retorne falso
  fimse
fimfuncao

funcao Empilhar(elemento : inteiro) : logico
inicio
  se PilhaCheia entao
    retorne falso
  senao
    topo <- topo + 1
    pilha[topo] <- elemento
    retorne verdadeiro
  fimse
fimfuncao

funcao Desempilhar : inteiro
inicio
  se PilhaVazia entao
    retorne -999
  senao
    elemento <- pilha[topo]
    pilha[topo] <- 0
    topo <- topo - 1
    retorne elemento
  fimse
fimfuncao
Inicio
  qtd <- 0
  x <- 0
  Inicializar
  // visualG não percebe diferença
  // entre variaveis maiuscula
  // e minusculas
  repita
    escreval("Bem vindo ao programa das Pilhas - FIFO ")
    escreval("---------------------------------------------")
    escreval("(E) para Empilhar         | (D) para desempilhar")
    escreval("(T) para imprimir o Topo  | (R) para imprimir o Resultado dos itens desempilhados")
    escreval("(L) Limpar pilha          | (Li)Listar pilha")
    escreval("(X) para Encerrar e imprimir a qtd de itens empilhados")
    escreval("---------------------------------------------")
    escreval
    leia(comando)
    escolha comando
    caso "li"
      listar_tudo
    caso "e"
      se PilhaCheia entao
        escreval("Pilha cheia")
      senao
        escreva("Digite o valor: ")
        leia(valor)
        se Empilhar(valor) entao
          qtd <- (qtd + 1)
          escreval("Valor empilhado!")
          escreval("")
        fimse
      fimse
    caso "d"
      se PilhaVazia entao
        escreval("Pilha vazia")
      senao
        valor <- Desempilhar
        x <- valor
        qtd <- (qtd - 1)
        escreval("Valor desempilhado: ", valor)
        escreval("")
      fimse
    caso "t"
      se PilhaVazia entao
        escreval("Pilha vazia")
      senao
        escreval("Topo: ", pilha[topo])
      fimse
    caso "r"
      escreval("o Resultado dos Itens Desempilhados São: ")
      para i de 4 ate 1 passo -1 faca
        escreval(pilha[i])
      fimpara
      escreval("Valor desempilhado: ", x)
      escreval
    caso "x"
      escreval("o Resultado dos Itens Desempilhados São: ")
      para i de 4 ate 1 passo -1 faca
        escreval(pilha[i])
      fimpara
      escreval("Valor desempilhado: ", x)
      escreval("")
    fimescolha
  ate comando = "x"
  se topo = 0 entao
    topo = 1
  fimse
  escreval("Pilha")
  para i de 4 ate 1 passo -1 faca
    escreval(pilha[i])
  fimpara
  escreval("A quantidade de intens empilhados é de : ", qtd)
Fimalgoritmo

Ana Caroline Martins · 5 de dezembro de 2021

@devair1010 @joshuayuuki

Estou fazendo a mesma atividade, e o exemplo q o @devair1010 passou não rodou no meu VisualG. Continuo com a mesmo dificuldade. Aparentemente faltou por o código para listagem, não está listando.... @joshuayuuki, você conseguiu fazer, ou seu professor passou a correção da atividade??? Me ajudaaaaa!

devair1010 · 5 de dezembro de 2021

@Ana Caroline Martins Qual a versão do compilador visualG que você está usando ? , a versão mais nova ainda tem bug's , e então é melhor usar a anterior , que é a versão 3.0.6.5 , e nessa versão está compilando faz a listagem normal ,

você pode baixar nesse link :

http://visualg3.com.br/baixe-o-visualg-3-0-7/

Role a página para baixo , lá está a versão 3.0.7 e na linha abaixo a versão 3.0.6.5 , estável .

Jonathan92 · 13 de setembro de 2022

Espero ajudar com alguma coisa, mesmo que o código esteja um pouco quebrado...

Algoritmo "pilhas"
var
     comando: caractere
     floor, qtd: inteiro
     pilha: vetor [1..10] de inteiro

Procedimento Menu()
Inicio
     Escreval()
     Escreval("                    Estrutura LIFO - Pilhas                ")
     Escreval("       --------------------------------------------------- ")
     Escreval()
     Escreval("           (E) Empilhar         | (D) Desempilhar          ")
     Escreval()
     Escreval("                 (X) Encerrar e Imprimir a Pilha           ")
     Escreval()
     Escreval("       --------------------------------------------------- ")
     Escreval()
FimProcedimento

Procedimento RenderizarMenu()
Inicio
     LimpaTela
     Menu
FimProcedimento

Procedimento Instancias()
Inicio
     floor <- 0
     qtd <- 0
FimProcedimento

Procedimento Empilhar()
var
     valor: inteiro
Inicio
     Escreval("                              EMPILHANDO...                              ")
     Escreval()

     Escreva ("       Digite um valor: ")
     leia (valor)

     Se PilhaCheia então
          Escreva ("            Pilha Cheia!!! ")
     senao
          // Armazenar na pilha
          Instancias()
          
          floor <- floor + 1
          pilha[floor] <- valor

          qtd <- qtd + 1
          Escreva ("Itens da Pilha: ", qtd)
          
          // Atualizar Itens da Pilha
          ListarPilha()
     FimSe
FimProcedimento

Funcao PilhaCheia(): logico
Inicio
     Se (floor > 10) então
          retorne verdadeiro
     senao
          retorne falso
     FimSe
FimFuncao

Procedimento Desempilhar()
var
     valor: inteiro
Inicio
     Escreval("                         DESEMPILHANDO...                         ")
     Escreval()
     
     Escreva ("       Remover o valor: ")
     leia (valor)

     Se PilhaCheia() então
          Escreva ("            Pilha Vazia!!! ")
     senao
          // Remover na pilha
          floor <- floor - 1
          pilha[floor] <- valor
     FimSe
     
     // Atualizar Lista
     ListarPilha()
FimProcedimento

Funcao PilhaVazia(): logico
Inicio
     Se (floor = 0) então
          retorne verdadeiro
     senao
          retorne falso
     FimSe
FimFuncao

Procedimento ListarPilha()
Inicio
     Escreval("                         LISTANDO...                         ")
     Escreval()

     // Listando os valores empilhados ou desempilhados
     Para i de 1 ate floor faca
          Escreva (i, "º Elemento da Pilha: ", pilha[i])
     FimPara
FimProcedimento

Procedimento LimparPilha()
Inicio
     Escreval("                         LIMPANDO...                         ")
     Escreval()

     pilha[floor] <- ""
FimProcedimento

Inicio
     Menu()
     
     // Camada de Input
     Escreva ("            Insira um comando: ")
     leia(comando)
     
     // Camada de Events da Pilha [Boas Práticas => Responsabilidade Única]
     Escolha comando
          Caso "E"
               RenderizarMenu()
               Empilhar()
          Caso "D"
               RenderizarMenu()
               Desempilhar()
          OutroCaso
               RenderizarMenu()
     FimEscolha
Fimalgoritmo