×
Ir ao conteúdo
  • Cadastre-se

VisualG VisualG - exercício pilhas - FILO


Ir à solução Resolvido por Simon Viegas,

Posts recomendados

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

 

imagem_2021-03-24_112048.png

  • Curtir 2
Link para o comentário
Compartilhar em outros sites

@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 .

  • Curtir 1
Link para o comentário
Compartilhar em outros sites

  • Moderador
  • Solução

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:

 

image.png

 

 

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 :D.

 

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

 

Veja:

image.png

 

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"

 

  • Curtir 2
  • Amei 1
Link para o comentário
Compartilhar em outros sites

@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! 

 

 

 

 

 

 

 

 

 

  • Curtir 1
Link para o comentário
Compartilhar em outros sites

@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

 

  • Amei 1
Link para o comentário
Compartilhar em outros sites

  • Simon Viegas alterou o título para VisualG - exercício pilhas - FILO
  • 8 meses depois...

@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!

  • Obrigado 1
Link para o comentário
Compartilhar em outros sites

@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 ,

1262668873_empilharvsualG.jpg.52d10ba9a4a761321109255000c950a3.jpg

  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 .

Link para o comentário
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisa ser um usuário para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades 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

×
×
  • Criar novo...

Curso de Hacker Ético

LANÇAMENTO!

CLIQUE AQUI E CONFIRA!

* Este curso não é ministrado pela equipe do Clube do Hardware.