VisualG Como resolver algoritmo vender e reservar

Cristian Herchonvicz · 13 de abril de 2022

Olá a todos, alguém pode me ajudar a como proceder em terminar este código?

Não estou conseguindo criar o processamento para fazer a opção reservar e vender o lote, lembrando que para isso funcionar eu preciso entrar com um nome de usuário, ou seja, se o nomeX, reservou o loteX, tem que ficar com o ele impresso na execução do código!

Se quiserem dar dicas de como fazer em outras formas é bem vindo também, o importante pra mim é terminar o código!

var
   lote: vetor[1..14] de inteiro
   nomecomprador: vetor[1..14] de caractere
   coluna: inteiro
   linha: inteiro
   nome: caractere
   op: inteiro
   
procedimento listarlote
Inicio
   para linha de 1 ate 14 passo 2 faca
      para coluna de 0 ate 1 faca
         Escreva(linha+coluna)
      fimpara
      Escreval()
   fimpara
fimProcedimento

procedimento reservalote
Inicio

fimProcedimento


procedimento compralote
Inicio

fimProcedimento

Inicio
   // Seção de Comandos, procedimento, funções, operadores, etc...
   Escreval("Bem vindos ao Consisa lote:")
   Escreval("Digite seu nome:")
   leia(nome)
   Escreval("Por favor selecione um item abaixo:")
   Escreval(" 1 Listar lotes")
   Escreval(" 2 Reservar lote")
   Escreval(" 3 Comprar lote")
   Escreval(" 4 Sair")
   Escreval("Opção:")
   leia(op)
   se op = 1 entao
      listarlote
   fimSe
   se op = 2 entao
      reservalote
   fimSe
   se op = 3 entao
      compralote
   fimSe
   se op = 4 entao
      //fimalgoritmo
   fimSe

fimAlgoritmo

kgin · 14 de abril de 2022

Poste o enunciado.

Cristian Herchonvicz · 14 de abril de 2022

@kgin Está escrito antes do código..

2 horas atrás, Cristian Herchonvicz disse:

Olá a todos, alguém pode me ajudar a como proceder em terminar este código?

Não estou conseguindo criar o processamento para fazer a opção reservar e vender o lote, lembrando que para isso funcionar eu preciso entrar com um nome de usuário, ou seja, se o nomeX, reservou o loteX, tem que ficar com o ele impresso na execução do código!

Se quiserem dar dicas de como fazer em outras formas é bem vindo também, o importante pra mim é terminar o código!

kgin · 14 de abril de 2022

@Cristian Herchonvicz Achei meio vago o enunciado.

tente fazer dessa maneira.

algoritmo "loteamentos"

var
   // Reserva dos lotes
   lotes_disponiveis:vetor [1..14] de inteiro
   // Nomes dos compradores dos lotes
   lotes_nomes:vetor [1..14] de caractere
   // Quantidade de lotes
   QUANTIDADE_LOTES:inteiro
   contador:inteiro
   LOTE_DISPONIVEL, LOTE_RESERVADO, LOTE_VENDIDO:inteiro
   
procedimento mostraLotes
var
   contador:inteiro

inicio
   escreval("Lotes disponivies")
   para contador de 1 ate QUANTIDADE_LOTES faca
      // Mostra se o lote está disponível
      se lotes_disponiveis[contador] = LOTE_DISPONIVEL entao
         escreval("[", contador,"]-Lote disponiviel")
      fimSe
      
      se lotes_disponiveis[contador] = LOTE_RESERVADO entao
         escreval("[", contador,"]-Lote reservado para ", lotes_nomes[contador])
      fimSe
      
      se lotes_disponiveis[contador] = LOTE_VENDIDO entao
         escreval("[", contador,"]-Lote vendido para ", lotes_nomes[contador])
      fimSe
   fimPara
fimProcedimento

procedimento reservaLote
var
   indice:inteiro
   opcao:inteiro
   
inicio
   // Mostra os lotes
   mostraLotes
   escreval("Digite um lote para reservar ou comprar")
   leia(indice)
   // Checa se o valor do lote e valido
   se (indice >= 1) e (indice <= QUANTIDADE_LOTES) entao
      // Verifica se o lote está disponível
      se lotes_disponiveis[indice] = 0 entao
         escreval("Digite seu nome para confirmar a reserva")
         leia(lotes_nomes[indice])
         escreval("Digite 1 para reservar o lote ou 2 para comprar")
         leia(opcao)
         
         se opcao = 1 entao
            lotes_disponiveis[indice] <- LOTE_RESERVADO
         seNao
            lotes_disponiveis[indice] <- LOTE_VENDIDO
         fimSe
         
      seNao
         se lotes_disponiveis[indice] = LOTE_RESERVADO entao
            escreval("Lote ja reservado")
         seNao
            escreval("O lote ja foi comprado")
         fimSe
         escreval("Deseja tentar reservar ou comprar outro lote?")
         escreval("Digite 1 para cadastrar novamente ou 2 para sair")
         leia(opcao)
         se opcao = 1 entao
            reservaLote
         fimSe
      fimSe
   seNao
      escreval("Essa opcao não existe")
      escreval("Deseja tentar reservar ou comprar outro lote")
      escreval("Digite 1 para cadastrar novamente ou 2 para sair")
      leia(opcao)
      se opcao = 1 entao
         reservaLote
      fimSe
   fimSe
fimProcedimento
   
inicio
   // Quantidade total de lotes
   QUANTIDADE_LOTES <- 14
   // Constantes do status do lote
   LOTE_DISPONIVEL <- 0
   LOTE_RESERVADO <- 1
   LOTE_VENDIDO <- 2
   // Inicia o vetor
   para contador de 1 ate QUANTIDADE_LOTES faca
      lotes_disponiveis[contador] <- 0
   fimPara

   reservaLote
   mostraLotes

fimAlgoritmo

Simon Viegas · 14 de abril de 2022

@kgin, muito bacana o teu código... imagino que já adianta muito coisa pro projeto (vai depender do enunciado, rs).

Uma sugestão seria declarar as constantes diretamente (em vez de deixar como variáveis e setar os valores no corpo):

algoritmo "loteamentos"
const
   QUANTIDADE_LOTES = 14
   LOTE_DISPONIVEL = 0
   LOTE_RESERVADO = 1
   LOTE_VENDIDO = 2

var
   lotes_disponiveis: vetor [1..QUANTIDADE_LOTES] de inteiro
   lotes_nomes: vetor [1..QUANTIDADE_LOTES] de caractere
   contador: inteiro

Inclusive já usar o parâmetro na própria criação dos vetores.

Só um adendo:

Esse trecho está dentro do procedimento reservarLote, certo? Daí "não pode" invocar novamente o próprio método (nem poderia invocar um outro externo com objetivo de navegação entre partes..., pois o procedimento "atual" continua aberto... vai ficar "empilhando processos"). Um mais correto seria estruturar um laço de repetição.

@Cristian Herchonvicz, por favor, poste o texto completo do enunciado. A estrutura do programa vai depender dos "requisitos" naquilo que foi solicitado... não adiantar fazer um programa todo lindo e rodando certo se não foi o que foi pedido.

ABAIXO UM REFATORADA NO CÓDIGO ORIGINAL

Refatorada 1:
- inserção das constantes (como sugerido pelo @kgin);

- ajustes de algumas nomenclaturas de variáveis;

- uso de variáveis LOCAIS dentro dos procedimentos;

- alinhamento da exibição dos lotes.

algoritmo "Consisa Lote | Compra e Venda de Loteamentos"
const
   QUANTIDADE_LOTES = 14
   LOTE_DISPONIVEL = 0
   LOTE_RESERVADO = 1
   LOTE_VENDIDO = 2

var
   lotesStatus: vetor[1..QUANTIDADE_LOTES] de inteiro
   nomesCompradores: vetor[1..QUANTIDADE_LOTES] de caractere
   nomeComprador: caractere
   op: inteiro

procedimento listarLote()
var
   coluna: inteiro
   linha: inteiro
Inicio
   para linha de 1 ate 14 passo 2 faca
      para coluna de 0 ate 1 faca
         escreva(linha+coluna)
      fimPara
      escreval()
   fimPara
fimProcedimento

procedimento reservarLote()
inicio

fimProcedimento


procedimento comprarLote()
inicio

fimProcedimento

inicio
   escreval("Bem vindos ao Consisa Lote:")
   escreval()
   escreval("Digite seu nome:")
   leia(nomeComprador)
   escreval()
   escreval("Por favor selecione um item abaixo:")
   escreval(" 1 Listar lotes")
   escreval(" 2 Reservar lote")
   escreval(" 3 Comprar lote")
   escreval(" 4 Sair")
   escreva ("Opção: ")
   leia(op)
   
   se op = 1 entao
      listarLote()
   fimSe
   
   se op = 2 entao
      reservarLote()
   fimSe
   
   se op = 3 entao
      compraLote()
   fimSe
fimAlgoritmo

Refatorada 1:

- utilizar caracteres para representar os "status" dos lotes;

- simplificação do fluxo para testes. (Não precisar ficar digitando)

algoritmo "Consisa Lote | Compra e Venda de Loteamentos"
const
   QUANTIDADE_LOTES = 14
   LOTE_DISPONIVEL = "_"
   LOTE_RESERVADO = "R"
   LOTE_VENDIDO = "V"

var
   lotesStatus: vetor[1..QUANTIDADE_LOTES] de caractere
   nomesCompradores: vetor[1..QUANTIDADE_LOTES] de caractere
   nomeComprador: caractere
   op: inteiro



procedimento inicializarStatusLote()
var
   i: inteiro
inicio
   para i de 1 ate QUANTIDADE_LOTES faca
      lotesStatus[i] <- LOTE_DISPONIVEL
   fimPara
fimProcedimento



procedimento listarLote()
var
   i: inteiro
Inicio
   escreval("LISTA DE LOTES")

   para i de 1 ate QUANTIDADE_LOTES faca
      escreva(i:3, " [", lotesStatus[i], "]")
      se (i mod 2 = 0) entao
         escreval()
      fimSe
   fimPara
fimProcedimento



procedimento reservarLote()
inicio
   lotesStatus[3] <- LOTE_RESERVADO
fimProcedimento



procedimento comprarLote()
inicio

fimProcedimento



inicio
   inicializarStatusLote()

   escreval("Bem vindos ao Consisa Lote:")
   escreval()
   escreva ("Digite seu nome: ")
   //leia(nomeComprador) {Por enquanto, para não precisar ficar digitando}
   nomeComprador <- "Maria Joaquina"
   escreval(nomeComprador)
   escreval()
   escreval("Por favor selecione um item abaixo:")
   escreval(" 1 Listar lotes")
   escreval(" 2 Reservar lote")
   escreval(" 3 Comprar lote")
   escreval(" 4 Sair")
   escreva ("Opção: ")
   //leia(op)

   escreval()

   listarLote()
   reservarLote()
   listarLote()
fimAlgoritmo

Observem que assim só faço rodar... obviamente as implementações estão incompletas... até mesmo porque precisa do enunciado completo para ter uma base melhor...

@Cristian Herchonvicz, você não precisa necessariamente seguir os nossos código, ok? A ideia é que você vá entendendo pelos exemplos e replicando as ideias no teu próprio código...

Posta aí o enunciado que a depender pode ir refazendo aos poucos... a parte da modelagem inicial é a parte mais importante... todo o código vai ser estruturado de acordo com a estrutura dos dados.

Só um adendo. Sobre:

3 minutos atrás, Simon Viegas disse:

Esse trecho está dentro do procedimento reservarLote, certo? Daí "não pode" invocar novamente o próprio método (nem poderia invocar um outro externo com objetivo de navegação entre partes..., pois o procedimento "atual" continua aberto... vai ficar "empilhando processos"). Um mais correto seria estruturar um laço de repetição.

Ao chamar um procedimento pode ter a ideia de um "vá para" (GoTo)... mas no VisualG (e na maioria das linguagens do mundo real), na verdade é "invocado um NOVO método", ou seja, imaginem que um procedimento seja um programa do Windows... cada vez que chama-o, abriria um novo processo... daí, ao invocar um procedimento dentro do procedimento, aconteceria algo como:

programa_principal
   reservaLote()1
   reservaLote()2
   reservaLote()3
   ...

Nisso, cada "processo" desse tem as suas próprias estruturas de variáveis,

Ou seja, o 1 invoca 2... daí o 1 fica parado esperando terminar o 2. Se o 2 chamar o 3, vai ficar parado tb e esperar o 3... assim por diante. Quando o 3 terminar, volta para 2, que ao terminar volta para 1, que ao terminar volta para o programa principal... um mais correto seria o programa principal invocar um método, que volta para o principal. Que invoca um método e volta... por aí vai... Mas sobre isso dps a gente pode conversar com mais calma, se quiserem...

kgin · 14 de abril de 2022

2 horas atrás, Simon Viegas disse:

Uma sugestão seria declarar as constantes diretamente (em vez de deixar como variáveis e setar os valores no corpo):

Procurei por todo canto e não achei nada sobre constantes.

Pensei que nem existissem no visualG.

2 horas atrás, Simon Viegas disse:

Esse trecho está dentro do procedimento reservarLote, certo? Daí "não pode" invocar novamente o próprio método (nem poderia invocar um outro externo com objetivo de navegação entre partes..., pois o procedimento "atual" continua aberto... vai ficar "empilhando processos"). Um mais correto seria estruturar um laço de repetição.

Eh erro meu isso aí, não seria um exemplo muito bom pra que tá aprendendo a programar.

Mas em C ou pascal dependendo da arquitetura e a quantidade de memória isso não seria um problema.

a recursão poderia ser feita até umas 64 vezes em C (no pior dos casos) ou umas 128 vezes em pascal se obedece-se algumas regras.

Eu achei incrível isso tenha funcionado no visualG.

Simon Viegas · 14 de abril de 2022

36 minutos atrás, kgin disse:

Mas em C ou pascal dependendo da arquitetura e a quantidade de memória isso não seria um problema.

Rodar, acho que rodaria de boa... seria mais pelas questão dos princípios mesmo, relacionados aos paradigmas da linguagem*.

Outro exemplo seria esse:

20 horas atrás, Cristian Herchonvicz disse:
   se op = 4 entao
      fimAlgoritmo
   fimSe

O comando fimAlgoritmo não seria para "foçar finalizar o programa". Este é um comando relacionado o inicio para delimitar a parte do programa principal. Não poderia ser utilizar como no exemplo acima. É um erro. O programa roda porque o VisualG é "bugado" e não compila, ele interpreta em execução... daí nem o VisualG percebe que tá errado.

Seria como fazer no Pascal algo assim:

if (op = 4) then
begin
  end.
end;

Entende? Lá no Pascal acho que existe o exit e o halt. Que seriam especificamente para isso (forçar a finalização...)... ou seja, no VisualG não existe um comando equivalente, como sair ou parar. Mas mesmo no Pascal não se usaria halt, um mais correto seria deixar o fluxo continuar até chegar no end. lá do final.

Cristian Herchonvicz · 18 de abril de 2022

Boa noite senhores, o enunciado seria basicamente criar um algoritmo que simulasse uma corretora de imóveis e que nesse algoritmo ele teria que ter 2 opções somente: a primeira de que o cliente X poderia RESERVAR E COMPRAR o LOTE disponível, no meu caso usei 14 lotes disponíveis. Quando o cliente X reserva ou compra o lote X, o mesmo tem que estar listado para que o próximo cliente não selecione o lote reservado/comprado pelo cliente x.

Vendo aqui as soluções que vocês disponibilizaram me clareou bastante a cabeça em como terminar o código. Vou tentar terminar ele amanhã e se tiver sem problemas posto o resultado final aqui e fecho o tópico..
Desculpem a falta de clareza no enunciado (falha minha), na próxima se tiver serei mais claro e objetivo e OBRIGADO aos que responderam e pelas dicas!!!!

Cristian Herchonvicz · 21 de abril de 2022

Bom dia senhores, tenho uma solução um pouco diferente da que eu comecei fazer, mas na programação o importante é o código funcionar.. Colocarei o código completo aqui, fiquem a vontade para colocar dicas, melhorias e afins...

Algoritmo "Loteamento"
// Disciplina   : [Linguagem e Lógica de Programação]
// Professor   : Antonio Carlos Nicolodi 
// Descrição   : Aqui você descreve o que o programa faz! (função)
// Autor(a)    : Cristian Herchonvicz
// Data atual  : 21/04/2022
Var
// Seção de Declarações das variáveis 
lotevazio: vetor[1..14] de inteiro
lotedestinado: vetor [1..14] de caractere
resposta, nome:caractere
grupoA, grupoB, lote, vendido, op, esc: Inteiro

Procedimento listadelote()
Inicio
Escreval("Bem vindos ao Loteamento Consisa!!!")
para grupoA <- 1 ate 14 passo 2 faca
     Escreva("||")
     para grupoB <- 0 ate 1 faca
          se (lotevazio[grupoA + grupoB] = 0) entao
             Escreva(" [Lote",grupoA + grupoB:3,"]")
          fimse
          se (lotevazio[grupoA + grupoB] = 1) entao
             Escreva(" [Reservado para ", lotedestinado[grupoA + grupoB], "]")
          fimse
          se (lotevazio[grupoA + grupoB]= 2) entao
             Escreva(" [Vendido para ", lotedestinado[grupoA + grupoB], "]")
             vendido<-vendido+1
          fimse
     fimpara
     Escreval()
fimPara
fimprocedimento

Inicio
// Seção de Comandos, procedimento, funções, operadores, etc... 
repita
esc<-0
vendido<-0
listadelote()
se vendido = 14 entao
   limpatela
   listadelote()
   interrompa
fimse
     Escreval("Insira o nome do Cliente:")
     leia(nome)
     EscrevaL("Bem vindo a loja de compra de lotes: ", nome)
     EscrevaL("Com base aos lotes vagos a cima, de '1 a 14', qual deseja comprar?")
     leia(lote)
     se (lote>14) e (lote<1) ou (lotedestinado[lote] <> (nome)) e (lotedestinado[lote] <> "") entao
        Escreval("Lote indisponivel. Tente Novamente")
     senao
     repita
           se lotevazio[lote] = 2 entao
           limpatela
           Escreval("Lote já comprado")
           interrompa
           fimse
                Escreval("Você deseja:")
                Escreval("1  Reservar o Lote")
                Escreval("2  Comprar o lote")
                Escreval("3  Listar lotes")
                Escreval("4  Sair")
                Escreval("Resposta:")
                leia(op)
                Escreval
                Escolha op
                Caso 1
                lotevazio[lote]<-1
                lotedestinado[lote] <- (nome)
                Escreval("O Lote ",lote," acaba de ser reservado para ", nome)
                esc<-1
                Caso 2
                lotevazio[lote]<- 2
                lotedestinado[lote] <- (nome)
                Escreval("O Lote ",lote," acaba de ser comprado por ", nome)
                esc<-1
                Caso 3
                lotevazio[lote]<-1
                lotedestinado[lote] <- (nome)
                listadelote()
                Caso 4
                fimalgoritmo
                outroCaso
                limpatela
                Escreval("Erro. Verifique se sua escolha é uma das listadas.")
                fimescolha
                ate esc=1
     fimse
     Escreval("Deseja reservar ou comprar outro Lote? sim/não")
     leia(resposta)
     resposta<-(resposta)
     ate(resposta="não")

Fimalgoritmo