Portugol código em portugol nível hard

Filipe Gomes · 17 de abril de 2020

Pessoal venho pedir ajuda de alguém que tenha a boa vontade de me ajudar. Pago uma cadeira de Lógica na facul e o professor me passou a seguinte questão pra ajudar na pontuação :

"Escreva um algoritmo para gerenciamento de um uma pizzaria. O restaurante tem 8 mesas e 2 garçons. Os pratos disponíveis para consumo são refrigerante (R$ 10,00), Pizza pequena (R$ 20,00), pizza média (R$ 35,00) e pizza grande (R$ 50,00). O programa deve começar no início de um dia de operação e só finalizar com o comando de geração do apurado diário informando o consumo por mesa e o acumulado das gorjetas por garçons, 10% de cada conta. As mesas são reutilizadas e sempre que um cliente terminar uma refeição o programa deve gerar a conta de cada mesa. Durante a operação diária, o sistema deve informar qual mesa está ocupada ou livre."

Mano eu estou com sérias dificuldades de montar esse código. Já tentei mas não consigo evoluir, alguém aí pode me ajudar ?!

DiF · 17 de abril de 2020

Caro usuário,

Seja bem-vindo ao Fórum do Clube do Hardware.

No intuito de servir como fonte de pesquisa no caso de instituições de ensino, informamos que incorrer no resolvimento por completo de questões relacionadas a disciplinas escolares de cursos técnicos e faculdades podem ser revistas e removidas pela Equipe de Moderação do Clube do Hardware.

Para sanar dúvidas sobre esse tipo de problema, por gentileza, publique o passo a passo do desenvolvimento da questão, projeto, monografia ou conteúdo em dúvida para que possamos analisar se a resposta está correta ou não, ou para que possa ser auxiliado com a dúvida no desenvolvimento do exercício.

Infelizmente, não há como resolver os trabalhos pelos usuários. O objetivo do Fórum do Clube do Hardware é auxiliar seus usuários a encontrar soluções para que possam sanar suas dúvidas, e não de trazer soluções prontas para seus usuários. Além disso, copiar e colar respostas que não são de autoria própria do qualquer usuário é considerado plágio, o que é ilegal.

Esperamos que compreenda.

Atenciosamente,

Equipe Clube do Hardware

Simon Viegas · 17 de abril de 2020

@Filipe Gomes, poste o que já conseguiu fazer e em qual parte está com dúvidas.

Filipe Gomes · 17 de abril de 2020

@DiF Entendo sim, na vdd não quero que ninguém "resolva" pra mim, queria mesmo uma ajuda

adicionado 1 minuto depois

@Simon Viegas Man eu consigo criar o menu, e até sei por onde ir pra criar o resto, mas não sei como guardar em váriaveis temporarias

algoritmo "Pizzaria"
var
   opcao, qtdrefri, qtdpp, qtdpm, qtdpg : inteiro

procedimento CriarMenu()
inicio
   escreval("Digite [1] para Refrigerante")
   escreval("Digite [2] para Pizza P")
   escreval("Digite [3] para Pizza M")
   escreval("Digite [4] para Pizza G")
   escreval("Digite [5] para Fechar a conta")
   escreval("")
   escreval("Opção:")
fimProcedimento

inicio
   repita
      LimpaTela()
      CriarMenu()
      leia(opcao)
      se opcao =1 então
         escreval("Informe a quantidade de Refrigerantes:")
         leia (qtdrefri)
      fimse
      se opcao =2 entao
         escreval("Informe a quantidade de Pizzas tamanho P:")
         leia(qtdpp)
      fimse
      se opcao =3 entao
         escreval("Informe a quantidade de Pizzas tamanho M:")
         leia(qtdpm)
      fimse
      se opcao =4 entao
         escreval("Informe a quantidade de Pizzas tamanho G:")
         leia (qtdpg)
      fimse
   ate opcao=5
fimalgoritmo

Simon Viegas · 18 de abril de 2020

15 horas atrás, Filipe Gomes disse:

"Escreva um algoritmo para gerenciamento de um uma pizzaria. O restaurante tem 8 mesas e 2 garçons. Os pratos disponíveis para consumo são refrigerante (R$ 10,00), Pizza pequena (R$ 20,00), pizza média (R$ 35,00) e pizza grande (R$ 50,00). O programa deve começar no início de um dia de operação e só finalizar com o comando de geração do apurado diário informando o consumo por mesa e o acumulado das gorjetas por garçons, 10% de cada conta. As mesas são reutilizadas e sempre que um cliente terminar uma refeição o programa deve gerar a conta de cada mesa. Durante a operação diária, o sistema deve informar qual mesa está ocupada ou livre."

13 horas atrás, Filipe Gomes disse:

@Simon Viegas Man eu consigo criar o menu, e até sei por onde ir pra criar o resto, mas não sei como guardar em variáveis temporárias

Você pode ir armazenando os dados em vetores. Uma dica interessante é ir implementando pequenas coisas por vez.

É precisa entender o fluxo de funcionamento do contexto... a partir daí ir criando uma lógica que simule esse funcionamento.

Vou tentar ser objetivo mostrando um exemplo de proposta:

Sugiro começar pelo funcionamento do pedido, sem se preocupar com a questão de mesas disponíveis, por exemplo. Vamos lá:

Você poderia utilizar o número da mesa como referência para os pedidos, ou seja: todo pedido de uma mesma mesa vai para um mesmo pedido. Daí, cria um vetor que vai funcionar de modo que cada posição do vetor corresponderá a uma mesa (que por consequência será um pedido).

Algo assim:

var
   vetQtdRefri : vetor [1..8] de inteiro
   vetQtdPizzaP, vetQtdPizzaM, vetQtdPizzaG : vetor [1..8] de inteiro

Daí, se a mesa 5 pediu uma Pizza Média e 3 refrigerantes, bastaria atualizar a quantidade de itens para a respectiva mesa. Algo como:

vetQtdRefri[5]  <- vetQtdRefri[5] + 3
vetQtdPizzaM[5] <- vetQtdPizzaM[5] + 1

Está dando para entender? No final, a conta da mesa 5 será o cálculo utilizando cada um dos vetores na posição 5. Por ai vaí.

Segue um exemplo de base:

algoritmo "Pizzaria"

var
   vetQtdRefri : vetor [1..8] de inteiro
   vetQtdPizzaP, vetQtdPizzaM, vetQtdPizzaG : vetor [1..8] de inteiro
   numMesa, numItem : inteiro
   opcao : caractere

procedimento MenuCardapio()
inicio
   escreval("[1] Refrigerante     R$ 10,00")
   escreval("[2] Pizza P          R$ 20,00")
   escreval("[3] Pizza M          R$ 35,00")
   escreval("[4] Pizza G          R$ 50,00")
   escreva ("==>")
fimProcedimento

procedimento MenuOpcoes()
inicio
   escreval("[P] Inserir pedido")
   escreval("[F] Fechar a mesa ")
   escreval("[S] SAIR          ")
   escreva ("==>")
fimProcedimento

inicio
   repita
      LimpaTela()
      MenuOpcoes()
      leia(opcao)
      se opcao = "P" entao
         LimpaTela()
         escreva ("Número da Mesa: ")
         leia(numMesa)
         escreval("")
         LimpaTela()
         MenuCardapio()
         leia(numItem)
         se numItem = 1 entao
            vetQtdRefri[numMesa] <- vetQtdRefri[numMesa]+1
         senao
            se numItem = 2 entao
               vetQtdPizzaP[numMesa] <- vetQtdPizzaP[numMesa]+1
            fimSe
         fimSe
      senao
         se opcao = "F" entao
            escreva ("Em construção...")
            timer 2000
            timer 0
         fimSe
      fimSe
   ate opcao = "S"
fimalgoritmo

"Ah! reanalisei aqui e acho melhor primeiro ler a mesa.. vou colocar para ler as variáveis dentro dos procedimento para deixar a parte principal mais limpa... etc":

algoritmo "Pizzaria"

var
   vetQtdRefri : vetor [1..8] de inteiro
   vetQtdPizzaP, vetQtdPizzaM, vetQtdPizzaG : vetor [1..8] de inteiro
   numMesa, numItem : inteiro
   opcao : caractere

procedimento MenuCardapio()
inicio
   LimpaTela()
   escreval("[1] Refrigerante     R$ 10,00")
   escreval("[2] Pizza P          R$ 20,00")
   escreval("[3] Pizza M          R$ 35,00")
   escreval("[4] Pizza G          R$ 50,00")
   escreva ("==>")
   leia(numItem)
fimProcedimento

procedimento MenuOpcoes()
inicio
   LimpaTela()
   escreval("[P] Inserir pedido")
   escreval("[F] Fechar a mesa ")
   escreval("[S] SAIR          ")
   escreva ("==>")
   leia(opcao)
fimProcedimento


procedimento LerMesa()
inicio
   LimpaTela()
   escreva ("Número da Mesa: ")
   leia(numMesa)
fimProcedimento

inicio
   repita
      LerMesa()
      MenuOpcoes()
      se opcao = "P" entao
         MenuCardapio()
         se numItem = 1 entao
            vetQtdRefri[numMesa] <- vetQtdRefri[numMesa]+1
         senao
            se numItem = 2 entao
               vetQtdPizzaP[numMesa] <- vetQtdPizzaP[numMesa]+1
            fimSe
         fimSe
      senao
         se opcao = "F" entao
            escreva ("Em construção...")
            timer 2000
            timer 0
         fimSe
      fimSe
   ate opcao = "S"
fimalgoritmo

Por aí vai... vá fazendo testes e testes a vendo que o que fica melhor... com o tempo vai ganhando experiência e cada vez mais vai utilizando recursos que já domina e/ou já tem uma ideia de como vai ficar... no início tem que ir testando mesmo e ajustando mesmo.

Outro exemplo de "ajustes":

Deixei os menus em procedimentos separados;
Criei um procedimento para cada leitura de dados;
Criei um procedimento para tratar a adição de item na mesa.

algoritmo "Pizzaria"

var
   vetQtdRefri : vetor [1..8] de inteiro
   vetQtdPizzaP, vetQtdPizzaM, vetQtdPizzaG : vetor [1..8] de inteiro
   numMesa, numItem : inteiro
   opcao : caractere

procedimento MenuCardapio()
inicio
   escreval("[1] Refrigerante     R$ 10,00")
   escreval("[2] Pizza P          R$ 20,00")
   escreval("[3] Pizza M          R$ 35,00")
   escreval("[4] Pizza G          R$ 50,00")
fimProcedimento

procedimento MenuOpcoes()
inicio
   escreval("[P] Inserir pedido")
   escreval("[F] Fechar a mesa ")
   escreval("[S] SAIR          ")
fimProcedimento

procedimento LerItemCardapio()
inicio
   LimpaTela()
   MenuCarpadio()
   escreva ("==>")
   leia(numItem)
fimProcedimento

procedimento LerOpcao()
inicio
   LimpaTela()
   MenuOpcoes()
   escreva ("==>")
   leia(opcao)
fimProcedimento

procedimento LerMesa()
inicio
   LimpaTela()
   escreva ("Número da Mesa: ")
   leia(numMesa)
fimProcedimento

procedimento AdicionarItemNoPedido()
inicio
   se numItem = 1 entao
      vetQtdRefri[numMesa] <- vetQtdRefri[numMesa]+1
   senao
      se numItem = 2 entao
         vetQtdPizzaP[numMesa] <- vetQtdPizzaP[numMesa]+1
      fimSe
   fimSe
fimProcedimento

inicio
   repita
      LerMesa()
      LerOpcao()
      se opcao = "P" entao
         LerItemCardapio()
         AdicionarItemNoPedido()
      senao
         se opcao = "F" entao
            escreva ("Em construção...")
            timer 2000
            timer 0
         fimSe
      fimSe
   ate opcao = "S"
fimalgoritmo

Veja... tudo isso é um esboço inicial... o segredo é ir fazendo aos poucos e ir testando. NÃO TENTE FAZER TUDO DE UMA VEZ...

Por aí vai. Veja se esta lógica de utilizar vetores posicionando pelo número da mesa é interessante. Você pode criar sua própria lógica inicial ou ir se baseando por essas acima.

A medida que o programa vai crescendo, vai inserindo recursos novos.

Tente fazer algo. Qualquer coisa poste o código teu completo atual e em qual parte parte está com dúvidas ou precisa de ajuda.

No aguardo.

Filipe Gomes · 18 de abril de 2020

@Simon Viegas Caramba teu código ficou muito mais didático usando vetores, é algo que não domino ainda. Fiz algumas modificações no meu código, estava indo numa linha mais difícil:

Algoritmo "Pizzaria"
//

Var
mesa_1, mesa_2, mesa_3, mesa_4, mesa_5, mesa_6, mesa_7, mesa_8: inteiro
mesa, garcon_1, garcon_2: inteiro
qtdrefri, qtdpp, qtdpm, qtdpg, valor_parcial, temp : inteiro
refri, pizza_p, pizza_m, pizza_g: inteiro
opcao: caracter

procedimento CriarMenu()
inicio
      Escreval("Digite [1] para Refrigerante:",qtdrefri)
      Escreval("Digite [2] para Pizza P:",qtdpp)
      Escreval("Digite [3] para Pizza M:",qtdpm)
      Escreval("Digite [4] para Pizza G:",qtdpg)
      Escreval("Digite [5] para Fechar a conta:", valor_parcial)
      Escreval("")

fimprocedimento
procedimento CalcularQtd (var qtd:inteiro)
var temp: inteiro
inicio
      leia(temp)
      qtd<- qtd+temp
fimprocedimento

procedimento opções()
inicio
repita
      Escreval("Opção:")
      leia(opcao)

           escolha (opcao)
                   caso "1"
                        escreval("Informe a quantidade de Refrigerantes:")
                        CalcularQtd( qtdrefri)
                   caso "2"
                        escreval("Informe a quantidade de Pizzas tamanho P:")
                        CalcularQtd (qtdpp)
                   caso "3"
                        escreval("Informe a quantidade de Pizzas tamanho M:")
                        CalcularQtd(qtdpm)
                   caso "4"
                        escreval("Informe a quantidade de Pizzas tamanho G:")
                        CalcularQtd (qtdpg)
           fimescolha
ate opcao= "5"
fimprocedimento
      .
Inicio

refri<-10
pizza_p<-20
pizza_m<-35
pizza_g<-50
valor_parcial<-qtdrefri+qtdpp+qtdpm+qtdpg

Escreval("Digite o número da mesa a ser atendida:")
leia(mesa)
           escolha (mesa)
                   caso =1
                      CriarMenu
                      opções
                      mesa_1<-valor_parcial
                         Escreval("O valor da conta é ",valor_parcial)
                   caso = 2
                      CriarMenu
                      opções
                      mesa_2<-valor_parcial
                   caso = 3
                      CriarMenu
                      opções
                      mesa_3<-valor_parcial
                   caso = 4
                      CriarMenu
                      opções
                      mesa_4<-valor_parcial
                   caso = 5
                      CriarMenu
                      opções
                      mesa_5<-valor_parcial
                   caso = 6
                      CriarMenu
                      opções
                      mesa_6<-valor_parcial
                   caso = 7
                      CriarMenu
                      opções
                      mesa_7<-valor_parcial
                   caso = 8
                      CriarMenu
                      opções
                      mesa_8<-valor_parcial
           fimescolha
           
FimAlgoritmo

Simon Viegas · 18 de abril de 2020

@Filipe Gomes, por favor, edite tua postagem anterior, apague o código que está lá e reinsira-o utilizado a BOX CODE. Basta antes clicar no botão <> e colocar o código na tela que vai abrir. Abaixo a localização do botão:

Filipe Gomes · 18 de abril de 2020

@Simon Viegas ok já fiz isso

Simon Viegas · 18 de abril de 2020

Muito bom! Está no caminho... mas precisa dar uma reorganizada no fluxo do uso das variáveis. Vou analisar o teu código aqui como mais calma e já já posto um complemento de resposta...

adicionado 49 minutos depois

@Filipe Gomes, resumidamente:

O cálculo da variável valor_parcial deve ser feito após ter as quantidades.
Para ideia do teu menu com a lista de itens funcionar, precisaria ficar chamado o menu novamente após cada novo item inserido na lista. Desta forma os valores no menu serão atualizados.

Tente efetuar esses ajustes e posta o código aqui.

Filipe Gomes · 19 de abril de 2020

@Simon Viegas valeu pela disponibilidade, mas eu estou oficialmente desistindo. Era uma pontuação extra bacana, mas não consigo evoluir e cada tentativa fica mais frustante. Enfim obrigado pela ajuda man

Filipe Gomes · 28 de abril de 2020

Pessoal acbaei resolvendo (com alguma ajuda) o código, bem hard mesmo. Resolvi postar a resolução, para futuras pesquisas se alguém precisar.

Algoritmo "Pizzaria"
Var
   mesa1, mesa2, mesa3, mesa4, mesa5, mesa6, mesa7, mesa8, total: real
   mesa1o, mesa2o, mesa3o, mesa4o, mesa5o, mesa6o, mesa7o, mesa8o: inteiro
   garcom1, garcom2: real
   refrigerante, pizza_p, pizza_m, pizza_g, conta, conta_individual: real
   dez_porcento, temp: real
   qtd_refrigerante, qtd_pizza_p, qtd_pizza_m, qtd_pizza_g: real
   opcao, x: caracter

procedimento escreveMenu()
inicio

   escreval("Mesas livres (0) e ocupadas (1)")
   escreval("Mesa 1 (",mesa1o,");Mesa 2 (",mesa2o,");Mesa 3 (",mesa3o,");Mesa 4 (",mesa4o,")")
   escreval("Mesa 5 (",mesa5o,");Mesa 6 (",mesa6o,");Mesa 7 (",mesa7o,");Mesa 8 (",mesa8o,")")
   escreval("")
   escreval("Selecione a opção desejada: ")
   escreval("")
   escreval("Digite R para dar entrada no número de refrigerantes (",qtd_refrigerante,")")
   escreval("Digite P para dar entrada no número de pizzas pequenas(",qtd_pizza_p,")")
   escreval("Digite M para dar entrada no número de pizzas médias (",qtd_pizza_m,")")
   escreval("Digite G para dar entrada no número de pizzas grandes (",qtd_pizza_g,")")
   escreval("Digite O para ocupar uma mesa")
   escreval("Digite C para calcular a conta")
   escreval("")
   escreval("Digite F para finalizar e apurar o valor do dia")
   escreval("")
   escreva("Digite a sua opção: ")
fimprocedimento

procedimento adicionar(var quantidade: inteiro)
var qtd: inteiro
inicio  leia(qtd)
   quantidade <- quantidade + qtd
fimprocedimento

Inicio
   refrigerante <- 10
   pizza_p <- 20
   pizza_m <- 35
   pizza_g <- 50
   repita
      escreveMenu
      leia(opcao)
      escolha (opcao)
      caso "O"
         escreva("Digite o número da mesa: ")
         leia(temp)
         escolha(temp)
         caso 1
            mesa1o <- 1
         caso 2
            mesa2o <- 1
         caso 3
            mesa3o <- 1
         caso 4
            mesa4o <- 1
         caso 5
            mesa5o <- 1
         caso 6
            mesa6o <- 1
         caso 7
            mesa7o <- 1
         caso 8
            mesa8o <- 1
         fimescolha
      caso "R"
         escreva("Digite quantos refrigerantes serão adicionados: ")
         adicionar(qtd_refrigerante)
      caso "P"
         escreva("Digite quantas pizzas pequenas serão adicionadas: ")
         adicionar(qtd_pizza_p)
      caso "M"
         escreva("Digite quantas pizzas médias serão adicionadas: ")
         adicionar(qtd_pizza_m)
      caso "G"
         escreva("Digite quantas pizzas grandes serão adicionadas: ")
         adicionar(qtd_pizza_g)
      caso "C"
         conta <- conta + qtd_refrigerante * refrigerante
         conta <- conta + qtd_pizza_p * pizza_p
         conta <- conta + qtd_pizza_m * pizza_m
         conta <- conta + qtd_pizza_g * pizza_g
         dez_porcento <- conta * 0.1

         escreva("Digite o número da mesa: ")
         leia(temp)
         escolha(temp)
         caso 1
            mesa1 <- mesa1 + conta + dez_porcento
            mesa1o <- 0
         caso 2
            mesa2 <- mesa2 + conta + dez_porcento
            mesa2o <- 0
         caso 3
            mesa3 <- mesa3 + conta + dez_porcento
            mesa3o <- 0
         caso 4
            mesa4 <- mesa4 + conta + dez_porcento
            mesa4o <- 0
         caso 5
            mesa5 <- mesa5 + conta + dez_porcento
            mesa5o <- 0
         caso 6
            mesa6 <- mesa6 + conta + dez_porcento
            mesa6o <- 0
         caso 7
            mesa7 <- mesa7 + conta + dez_porcento
            mesa7o <- 0
         caso 8
            mesa8 <- mesa8 + conta + dez_porcento
            mesa8o <- 0
         fimescolha
         escreva("Digite o número do garçom: ")
         leia(temp)
         escolha(temp)
         caso 1
            garcom1 <- garcom1 + dez_porcento
         caso 2
            garcom2 <- garcom2 + dez_porcento
         fimescolha

         escreva("Digite quantas pessoas tem na mesa: ")
         leia(temp)

         conta_individual <- (conta + dez_porcento) / temp
         escreval("Número de refrigerantes: ",qtd_refrigerante," : R$: ", qtd_refrigerante * refrigerante)
         escreval("Número de pizzas pequenas: ",qtd_pizza_p," : R$: ", qtd_pizza_p * pizza_p)
         escreval("Número de pizzas médias: ",qtd_pizza_m," : R$: ", qtd_pizza_m * pizza_m)
         escreval("Número de pizzas grandes: ",qtd_pizza_g," : R$: ", qtd_pizza_g * pizza_g)
         escreval("Dez porcento de serviço: : R$: ", dez_porcento)
         escreval("-------------------------------------------------")
         escreval("Valor total: : R$ ", conta + dez_porcento)
         escreval("Valor por pessoa: : R$ ",conta_individual)
         escreval("Aperte ENTER para continuar")
         leia(x)
         qtd_refrigerante <- 0
         qtd_pizza_p <- 0
         qtd_pizza_m <- 0
         qtd_pizza_g <- 0
         conta <- 0
         dez_porcento <- 0
      caso "F"
         escreval("")
      outrocaso
         escreval("Opção incorreta")
         escreval("Aperte ENTER para continuar")
         leia(x)
      fimescolha
      limpatela
   ate opcao = "F"
   total <- mesa1 + mesa2 + mesa3 + mesa4 + mesa5 + mesa6 + mesa7 + mesa8
   escreval("O apurado do dia foi: ",total)
   escreval("O consumo total da mesa 1 foi: ", mesa1)
   escreval("O consumo total da mesa 2 foi: ",mesa2)
   escreval("O consumo total da mesa 3 foi: ",mesa3)
   escreval("O consumo total da mesa 4 foi: ",mesa4)
   escreval("O consumo total da mesa 5 foi: ",mesa5)
   escreval("O consumo total da mesa 6 foi: ",mesa6)
   escreval("O consumo total da mesa 7 foi: ",mesa7)
   escreval("O consumo total da mesa 8 foi: ",mesa8)
   escreval("O garçom 1 recebeu: ",garcom1)
   escreval("O garçom 2 recebeu: ",garcom2)
fimalgoritmo

Simon Viegas · 28 de abril de 2020

@Filipe Gomes, antes de tudo:

2 horas atrás, Filipe Gomes disse:
escreval("Mesas livres (0) e ocupadas (1)")

Que migué foi esse aí? deixou a quantidade como um texto!!! As mesas livres e ocupadas vão aparece sempre iguais!

Vamos lá:

A lógica do algoritmo não me parece funcional. De um modo simplificado de falar, está misturando as contas das mesas. Todos os pedidos me parecem que estão indo para a mesma mesa. O correto é cada mesa ter os seus pedidos e sua própria conta!

Exemplo:

Mesa 2:

Garçom 2
3 Pizzas Médias;
2 refrigerantes

Mesa 5:

Garçom 1;
1 Pizza Grande;
4 refrigerantes.

Mesa 7:

Garçom 1;
2 Pizza Grande;
4 refrigerantes.

Quando for finalizar uma conta, precisa calcular de acordo com os itens da mesa...

OU de uma maneira mais simples, apenas utilizar uma mesa por vez, ou seja: perguntar qual o número da mesa seria apenas uma questão estética. Ao finalizar, iria acumulando os 10% de cada garçom.

Se for atendendo várias mesmas ao mesmo tempo, vou tentar exemplificar um desenvolvimento a partir do meu código anterior. Veja:

Mudei de se/senao para escolha/caso;
Inseri o conceito de garçom;

algoritmo "Pizzaria"

var
   vetQtdRefri : vetor [1..8] de inteiro
   vetQtdPizzaP, vetQtdPizzaM, vetQtdPizzaG : vetor [1..8] de inteiro
   vetGarconDaMesa : vetor [1..8] de inteiro //0 = disponível

   numMesa, numItem, numGarcom : inteiro
   opcao : caractere

procedimento MenuCardapio()
inicio
   escreval("[1] Refrigerante     R$ 10,00")
   escreval("[2] Pizza P          R$ 20,00")
   escreval("[3] Pizza M          R$ 35,00")
   escreval("[4] Pizza G          R$ 50,00")
   escreva ("==>")
fimProcedimento

procedimento MenuOpcoes()
inicio
   escreval("[P] Inserir pedido")
   escreval("[F] Fechar a mesa ")
   escreval("[S] SAIR          ")
   escreva ("==>")
fimProcedimento

inicio
   repita
      LimpaTela()
      MenuOpcoes()
      leia(opcao)

      escolha opcao
      caso "P"
         LimpaTela()
         escreva ("Número da Mesa: ")
         leia(numMesa)

         se (vetGarconDaMesa[numMesa] = 0) entao
            escreval("Mesa ainda não aberta")
            escreva ("Número do garçom: ")
            leia(numGarcom)
            vetGarconDaMesa[numMesa] <- numGarcom
         fimSe

         escreval("")
         LimpaTela()
         MenuCardapio()
         leia(numItem)

         escolha numItem
         caso 1
            vetQtdRefri[numMesa] <- vetQtdRefri[numMesa]+1
         caso 2
            vetQtdPizzaP[numMesa] <- vetQtdPizzaP[numMesa]+1
         fimEscolha //numItem
      caso "F"
         escreva ("Em construção...")
         timer 2000
         timer 0
      fimEscolha //opcao
   ate opcao = "S"
fimalgoritmo

Inserir menu de opções as quantidade já pedidas na mesa;

procedimento MenuCardapio(mesaAtual : inteiro)
inicio
   escreval("[1] Refrigerante     R$ 10,00", vetQtdRefri[mesaAtual])
   escreval("[2] Pizza P          R$ 20,00", vetQtdPizzaP[mesaAtual])
   escreval("[3] Pizza M          R$ 35,00", vetQtdPizzaM[mesaAtual])
   escreval("[4] Pizza G          R$ 50,00", vetQtdPizzaG[mesaAtual])
   escreva ("==>")
fimProcedimento

Ou seja: vai aparecer a quantidade para a mesa em questão.

Mostrar no Cardápio o número do Garçom;

procedimento MenuCardapio(numGarcom, mesaAtual : inteiro)
inicio
   escreval("")
   escreval(" MESA: ", mesaAtual:1, "Garçom: ", numGarcom:1)
   escreval("                               Qtd")
   escreval("[1] Refrigerante     R$ 10,00 ", vetQtdRefri[mesaAtual]:3)
   escreval("[2] Pizza P          R$ 20,00 ", vetQtdPizzaP[mesaAtual]:3)
   escreval("[3] Pizza M          R$ 35,00 ", vetQtdPizzaM[mesaAtual]:3)
   escreval("[4] Pizza G          R$ 50,00 ", vetQtdPizzaG[mesaAtual]:3)
   escreva ("==>")
fimProcedimento

Entende? vai implementado aos poucos! Vai vendo se está dando certo ou não... eu creio que vai... pois lá no início, já tinha uma noção que vou conseguir pegar a quantidade de cada mesa.

Vai inserindo mais coisas.

Possibilitar adicionar mais de um item de um vez
Opção cancelar para o cardápio;

         repita
            MenuCardapio(numGarcom, numMesa)
            leia(numItem)

            escolha numItem
            caso 1
               vetQtdRefri[numMesa] <- vetQtdRefri[numMesa]+1
            caso 2
               vetQtdPizzaP[numMesa] <- vetQtdPizzaP[numMesa]+1
            fimEscolha //numItem
            escreva ("Adicionar novo item? (S/N)")
            leia(repetir)
         ate repetir = "N"

Sair do cardápio pelo número do item, em vez de fazer uma pergunta

         repita
            limpaTela()
            MenuCardapio(numGarcom, numMesa)
            leia(numItem)

            escolha numItem
            caso 1
               vetQtdRefri[numMesa] <- vetQtdRefri[numMesa]+1
            caso 2
               vetQtdPizzaP[numMesa] <- vetQtdPizzaP[numMesa]+1
            fimEscolha //numItem
         ate numItem = 0

...

Por enquanto cheguei a isso:

algoritmo "Pizzaria"

var
   vetQtdRefri : vetor [1..8] de inteiro
   vetQtdPizzaP, vetQtdPizzaM, vetQtdPizzaG : vetor [1..8] de inteiro
   vetGarconDaMesa : vetor [1..8] de inteiro //0 = mesa disponível disponível

   numMesa, numItem, numGarcom : inteiro
   opcao, repetir : caractere

procedimento MenuCardapio(numGarcom, mesaAtual : inteiro)
inicio
   escreval("")
   escreval(" MESA: ", mesaAtual:1, "Garçom: ", numGarcom:1)
   escreval("                               Qtd")
   escreval("[1] Refrigerante     R$ 10,00 ", vetQtdRefri[mesaAtual]:3)
   escreval("[2] Pizza P          R$ 20,00 ", vetQtdPizzaP[mesaAtual]:3)
   escreval("[3] Pizza M          R$ 35,00 ", vetQtdPizzaM[mesaAtual]:3)
   escreval("[4] Pizza G          R$ 50,00 ", vetQtdPizzaG[mesaAtual]:3)
   escreval("")
   escreval("[0] CANCELAR")
   escreva ("==>")
fimProcedimento

procedimento MenuOpcoes()
inicio
   escreval("[P] Inserir pedido")
   escreval("[F] Fechar a mesa ")
   escreval("[S] SAIR          ")
   escreva ("==>")
fimProcedimento

inicio
   repita
      LimpaTela()
      MenuOpcoes()
      leia(opcao)

      escolha opcao
      caso "P"
         LimpaTela()
         escreva ("Número da Mesa: ")
         leia(numMesa)

         se (vetGarconDaMesa[numMesa] = 0) entao
            escreval("Mesa ainda não aberta")
            escreva ("Número do garçom: ")
            leia(numGarcom)
            vetGarconDaMesa[numMesa] <- numGarcom
         fimSe

         escreval("")
         LimpaTela()

         repita
            limpaTela()
            MenuCardapio(numGarcom, numMesa)
            leia(numItem)

            escolha numItem
            caso 1
               vetQtdRefri[numMesa] <- vetQtdRefri[numMesa]+1
            caso 2
               vetQtdPizzaP[numMesa] <- vetQtdPizzaP[numMesa]+1
            fimEscolha //numItem
         ate numItem = 0

      caso "F"
         escreva ("Em construção...")
         timer 2000
         timer 0
      fimEscolha //opcao
   ate opcao = "S"
fimalgoritmo

Cada coisa nova pode ir sendo inserida ao poucos... vai da criatividade e necessidade... assim como pode pensar em uma nova estruturação e ir modificando... a dica é que tentar ir fazendo aos poucos e tendo uma noção se está dando certo ou não...

Uma questão que me veio à cabeça:... quando é feito um pedido, é logo entregue na hora? pela lógica não, mas, para simplificar o algoritmo, podemos considerar que sim...

Vamos tentar implementar mais uma coisa...

Finalizar uma conta
Acúmulos dos 10% do garçom.

algoritmo "Pizzaria"

var
   vetQtdRefri : vetor [1..8] de inteiro
   vetQtdPizzaP, vetQtdPizzaM, vetQtdPizzaG : vetor [1..8] de inteiro
   vetGarconDaMesa : vetor [1..8] de inteiro //0 = disponível
   saldoGarcom : vetor [1..2] de real

   numMesa, numItem, numGarcom : inteiro
   opcao, repetir : caractere
   valorPedidos, valorConta, valorServico : real

procedimento MenuCardapio(numGarcom, mesaAtual : inteiro)
inicio
   escreval("")
   escreval(" MESA: ", mesaAtual:1, "Garçom: ", numGarcom:1)
   escreval("                               Qtd")
   escreval("[1] Refrigerante     R$ 10,00 ", vetQtdRefri[mesaAtual]:3)
   escreval("[2] Pizza P          R$ 20,00 ", vetQtdPizzaP[mesaAtual]:3)
   escreval("[3] Pizza M          R$ 35,00 ", vetQtdPizzaM[mesaAtual]:3)
   escreval("[4] Pizza G          R$ 50,00 ", vetQtdPizzaG[mesaAtual]:3)
   escreval("")
   escreval("[0] CANCELAR")
   escreva ("==>")

fimProcedimento

procedimento MenuOpcoes()
inicio
   escreval("[P] Inserir pedido")
   escreval("[F] Fechar a mesa ")
   escreval("[S] SAIR          ")
   escreva ("==>")
fimProcedimento

inicio
   repita
      LimpaTela()
      MenuOpcoes()
      leia(opcao)

      escolha opcao
      caso "P"
         LimpaTela()
         escreva ("Número da Mesa: ")
         leia(numMesa)

         se (vetGarconDaMesa[numMesa] = 0) entao
            escreval("Mesa ainda não aberta")
            escreva ("Número do garçom: ")
            leia(numGarcom)
            vetGarconDaMesa[numMesa] := numGarcom
         fimSe

         escreval("")
         LimpaTela()

         repita
            limpaTela()
            MenuCardapio(numGarcom, numMesa)
            leia(numItem)

            escolha numItem
            caso 1
               vetQtdRefri[numMesa] := vetQtdRefri[numMesa]+1
            caso 2
               vetQtdPizzaP[numMesa] := vetQtdPizzaP[numMesa]+1
            fimEscolha //numItem
         ate numItem = 0

      caso "F"
         escreval("Número da mesa")
         leia(numMesa)
         se (vetGarconDaMesa[numMesa] = 0) entao
            escreval("Mesa não tem conta aberta")
         senao
            valorPedidos := 0
            valorPedidos := valorPedidos + vetQtdRefri[numMesa]  * 10.00
            valorPedidos := valorPedidos + vetQtdPizzaP[numMesa] * 20.0
            valorPedidos := valorPedidos + vetQtdPizzaM[numMesa] * 35.00
            valorPedidos := valorPedidos + vetQtdPizzaG[numMesa] * 50.00
            valorServico := valorPedidos * 10/100
            valorConta   := valorPedidos + valorServico
            escreval("Valor da Conta   R$ ", valorPedidos:3:2)
            escreval("Valor do Servico R$ ", valorServico:3:2)
            escreval("")
            escreval("TOTAL            R$ ", valorConta:3:2)
            saldoGarcom[vetGarconDaMesa[numMesa]] := saldoGarcom[vetGarconDaMesa[numMesa]] + valorServico
         fimSe


         escreval("")
         escreval("Aguarde...")
         timer 2000
         timer 0
         escreval("")
      fimEscolha //opcao
   ate opcao = "S"
fimalgoritmo

Veja... cada implementação vai sendo como um esboço. Mas precisa ter uma noção que os dados que vai precisar vão está disponíveis... ou seja: como pensei possibilitando ter varias mesas ao mesmo tempo, pensei em utilizar vetores de modo que consiga armazenar e recuperar o que preciso.

Por ai vai...

Se futuramente tiver interesse de dar continuidade a esse meu código ou quiser tentar reformular para uma nova lógica, pensar em outra maneira de como poderia ser feito, estou á disposição.