Simon Viegas

Sobre:
 
Sobrepondo como? Seria bom demonstrar o erro.
 
Sobre>
 
Não use read(), utilize somente readln(). Troque isso já!
 
Após os ajustes, teste novamente e informe e demonstre o problema que está ocorrendo.
 
No aguardo.
Dica: utilize um replace de read( para readln(.

Isso. A cada ciclo é gerado apenas um valor, daí fica complicado tentar gerar dois valores ao mesmo tempo.
 
Você precisa entender primeiramente o cerne do problema (o que é uma Sequencia de Fibonacci?), daí tentar entender o algoritmo que gera essa sequência. Por fim, criar um algoritmo que gera determinada sequência ("gerar os 15 primeiros números da Sequencia de Fibonacci"), ou seja, atender ao enunciado...
 
RESUMO
- entender o que é Sequência de Fibonacci. Se te perguntar o que é você sabe responder?
- saber gerar uma Sequência de Fibonacci. Se te perguntar, você sabe gerar uma?
- atender aos requisitos do enunciado. Você precisa gerar um código que faça aquilo que está sendo pedido. (Isso vale para qualquer enunciado, vale para qualquer problema, ou seja, precisa ser feito aquilo que foi pedido para ser feito)

Só retorna o código da primeira letra, como destaquei na definição da função:
 
 
Ou seja: no VisualG não existe um tipo específico para "um caractere" (char), tem apenas para "um conjunto de caracteres" (string), daí, a função Asc() foi desenvolvida para "automaticamente" extrair a primeira letra da cadeia de caracteres que foi enviada. Ela sempre recebe um conjunto de caracteres (mesmo que tenha tamanho 1) e usa apenas o primeiro deles.
 
 
 
 
 
Um caminho é tentar buscar a definição da função:
 
 

 
 
Ou seja: ela recebe apenas UM inteiro. Logo, só tem como traduzir para UM caractere.
 
Adendo
Agora perceba: e mesmo assim, como o VisualG separaria onde começaria e onde terminaria cada código de caractere na "sequência" 761621031059997? O primeiro é 7 ou 76? Se o primeiro for 7, o próximo seria 6 ou 61? Se o primeiro for 76, o próximo seria 1 ou 16... ou 162? Saca?.... Esse tipo de "amadurecimento lógico" vai se criando a medida que vai se desenvolvendo.
,
CONCLUSÃO
Ambos só funcionando traduzindo uma código/caractere por vez.
 

@Caiomqc, um laço dentro de outro não ordenação nada em si. O que estaria fazendo a ordenação seria o algoritmo contigo no programa , ou seja, uma sequência de passos definidas para que tenham determinado comportamento ao serem executados. 
 
Isso é uma abstração: se tem um problema, rodam-se um programa e se obtém uma solução.
 
Assista alguns vídeos sobre laços de repetições. Vá vendo exemplos, até internalizar. É normal ter dúvidas ou dificuldades. Depois um tempo a ficha vai caindo e as "novidades" começam a ficar mais triviais. É preciso treinar para aprender a aprender mais facilmente.
 
Sobre as trocas de valores, você precisaria entender o algoritmo relacionado. Por exemplo, dê uma boa pesquisada sobre o Bubble Sort. É bem parecido com esse algoritmo acima. De um modo geral, é preciso primeiro entender o problema: "necessidade de ordenar um vetor desordenado". Daí buscar uma solução para ele.. só que no caso aqui, uma solução já está dada, ou seja, "um algoritmo pronto (que alguém ou um grupo inventou) que tem o tal papel de ordenar um vetor". Logo, seu papel seria apenas entender como funcionar esse algoritmo e usar. Entende?
 
Vá pesquisando e vendo exemplos. Entendendo o algoritmo de ordenação, vai entender porque e quando precisa fazer trocas de posições.

Então, o resto está no cerne do conceito de "divisível". É o resto que define se um número é divisível por outro ou não.
 
Se x dividido por 5 tem resto 0, então x é divisível por 5. Caso contrário, não o é. É isso.

@Caiomqc, corrija o algoritmo para evitar o erro mencionado.

A própria pergunta já diz a origem do problema... oras! você colocou para fazer isso!
 
 
Só deixar fora!
 
se (v >= 0) E (v <= 10) então tot010 <- tot010+1 fimSe se (v%2 = 1) então sImp <- sImp+v fimSe  
Adendo: os pares estão no conjunto dos inteiros, e não apenas dos naturais. Além disso, 0 é par! 

Pelo retorno da função em si, não. Não dá. Funções só retornam um valor. Uma forma seria utilizando vetores (array) ou utilizando registros (record), mas o VisualG não aceita. (Limitação da arquitetura - o desenvolvedor não implementou. No Pascal, pai do VisualG, aceita!)
 
Entretanto é possível retornar utilizando variáveis por referência (var) nos parâmetros... falei disso esses dias aqui:

Reforçando: já comece a procurar dar nomenclaturas mais semânticas. Isso ajuda até evitar se cansar. Acredite!. Tipo: "para que serve a mesmo?" ou "qual a variável que está armazenando a quantidade de alunos?".
 
Que tal: qtdAlunos? 
 
Veja como as expressões ficam mais autoexplicativas:
enquanto (cont <= qtdAlunos) faca  
Nem precisa do restante do código para inferir para que serve...
 
 
 
 
 
Você fez um algoritmo e não entendeu o que fez ou está analisando código de outra fonte?
 
Mas vamos lá:
 
A possível lógica aplicada seria que, a cada nova nota lida, verifica se essa nota é maior que a maior nota, ou seja, se for, essa nota atual seria a nova nota maior... Certo? Daí, quando essa condição for verdadeira, utiliza de uma variável auxiliar para copiar a tal nota e, como eventualmente quer o nome de quem tem a maior nota, também copia o nome... já que no contexto do algoritmo, estão relacionados.
 
Por exemplo, se quiser apenas o nome do aluno com a melhor nota, sem precisar da informação do valor da nota dele, utilizaria apenas a variável melhorAluno... Por aí vai. A solução sempre vai depende da necessidade.
 
 
O programa deve mostrar a nota e o nome do melhor aluno pois ao terminar de ler as notas (após o laço de repetição), vai está mostrando esses dados que foram obtidos.
 
Dica: vá pressionando F8 e acompanhando linha a linha. Veja no canto deito os valores da variáveis a vá entendendo o fluxo natural dos programas. O VisualG vai lendo da esquerda para direita, de cima para baixo (mas vai mostrando uma linha completa por vez). Quando chega num se, e a condição é verdadeira, o código "entra no se", caso contrário, o código pula... por isso que também o se é chamado de "desvio condicional", pois faz o código sair do tal fluxo natural. O laço de repetição é semelhante... só que a condição faz repetir ou não o código. Vá testando que vai assimilando... 

No VisualG não tem.
 
 
 
 
 
Após o comando caso é necessário ter um espaço (antes dos ").
 
 
 
 
 
Mesma causa raiz do anterior.
 
Dica: pressione Ctrl+G no VisualG para auto-indentação de código. Vá se acostumando com a indentação padrão, ou seja, como estava com esse erro (de não ter dado espaço), a indentação fica bagunçada.

@Joao Dz, eu testei carregar uma imagem da área de trabalho e funcionou normalmente. Tem certeza que os arquivos estão no caminho correto? além disso, veja se o arquivo está com a extensão, ou seja, deveria está "menu.png".
 
Teste o código abaixo e funcionou:
programa { inclua biblioteca Graficos --> g funcao inicio() { inteiro fundoMenu = g.carregar_imagem("C:/Users/Simon.Viegas/Desktop/JogoBio/boba.jpg") inteiro setaOP = g.carregar_imagem("C:/Users/Simon.Viegas/Desktop/JogoBio/porg.png") cadeia temp g.iniciar_modo_grafico(verdadeiro) g.definir_dimensoes_janela(800, 600) g.desenhar_imagem(0, 0, fundoMenu) g.desenhar_imagem(-100, -10, setaOP) g.renderizar() leia(temp) } }  

 
 
Observação:
Creio que seja mais interessante usar o caminho relativo, ou seja, em relação ao programa que está carregando a imagem. No caso, se as imagens estiverem na mesma pasta do arquivo ".por", poderia fazer algo assim:
 
inteiro fundoMenu = g.carregar_imagem("boba.jpg") inteiro setaOP = g.carregar_imagem("porg.png") Ou seja: seria algo como "<caminho onde está a pasta do programa>\boba.jpg" e idem para a outra imagem.
 
Se colocar numa subpasta, poderia ser:
inteiro fundoMenu = g.carregar_imagem("imgs/boba.jpg") inteiro setaOP = g.carregar_imagem("imgs/porg.png") Seria: "<caminho onde está a pasta do programa>\imgs\boba.jpg"...
 
 
Se deixar, por exemplo, o arquivo ".por" dentro da pasta "JogoBio/App" e as imagens dentro de "imgs". Ficaria assim:
inteiro fundoMenu = g.carregar_imagem("../imgs/boba.jpg") inteiro setaOP = g.carregar_imagem("../imgs/porg.png") Esse "../" refere-se a pasta anterior a pasta atual, daí vai acessar "<pasta anterior ao caminho onde está a pasta do programa>\imgs\boba.jpg"...
 
 
Por ai vai.
 
No aguardo.

Basicamente utilizando um laço de repetição. Conceito que já está utilizando.
 
Entenda assim: o VisualG é um interpretador de código, que vai executando linha a linha... daí, como quer "voltar", teríamos duas opções: ou de alguma forma fazer "pular" para a linha anterior desejada (conceito de label), ou deixar o trecho do código dentro de um laço de repetição, dessa forma, ao finalizar um laço dessa repetição, o interpretador entenderia que deveria ir para o início do laço.
 
Na prática, basicamente isso:
inicio repita escrevaL(" MENU PRINCIPAL ") escrevaL("------------------------------------------------") escrevaL("1 - LANCHES") escrevaL("2 - ACOMPANHAMENTOS") ... ate (opcao = 0) ... fimAlgoritmo  
Adendo: você está reutilizando a mesma variável para as opções, o que pode fazer perder informações entre as "telas". Precisa ajustar. Exemplo:
 
algoritmo "Nome ou descrição do programa" var opcao, codItem : inteiro inicio repita escrevaL(" MENU PRINCIPAL ") escrevaL("------------------------------------------------") escrevaL("1 - LANCHES") escrevaL("2 - ACOMPANHAMENTOS") escrevaL("3 - BEBIDAS") escrevaL("0 - PARA SAIR DO SISTEMA") escrevaL("------------------------------------------------") escrevaL("") escrevaL("Insira a opção desejada:") leia(opcao) escreval("") enquanto ((opcao < 0) OU (opcao > 3)) faca escrevaL("Opção inválida, digite novamente:") leia(opcao) fimEnquanto // Segunda tela do cardápio, o Menu de Lanches se (opcao = 1) então repita escrevaL(" LANCHES ") escrevaL("------------------------------------------------") escrevaL("1 - XTUDO------------R$17,00") escrevaL("2 - XBURGUER---------R$15,00") escrevaL("3 - XBACON-----------R$15,00") escrevaL("4 - XSALADA----------R$10,00") escrevaL("5 - XEGG-------------R$10,00") escrevaL("6 - MISTO QUENTE------R$8,00") escrevaL("7 - BIG BAURU--------R$16,00") escrevaL("0 - VOLTAR AO MENU PRINCIPAL") escrevaL("") escrevaL("Insira a opção desejada:") leia(codItem) escrevaL("") ate (codItem = 0) fimSe ate (opcao = 0) fimAlgoritmo  
Adendo: por uma questão de semântica, utilizei codItem... Nesse caso não teria problema utilizar essa mesma variável para o menu 2, menu 3 etc, percebe? Pois as informações que não podem ser perdidas são as entre "pai e filho", ou seja, entre o item de menu e o menu principal. Daí, se tiver outra opção como "quantidade de item", teria que ser outra variável, como por exemplo: qtdItens. Cada sub-nível dentro do seu próprio mundinho.
 
Adendo 2: veja como fica melhor opcao, codItem e qtdItem etc, em vez de algo como opcao1, opcao2, opcao3 etc.. Fica mais fácil para saber qual variável usar... ficaria estranho utilizar qtdItem lá no menu da escolha do item, saca? Logo, mais prático para se organizar.
 
Adendo 3: o nível de organização vai do enunciado e do que deseja implementar... seguindo uma lógica, se tem "validação de entrada para o menu principal" seria sensato fazer o mesmo para cada sub item de menu lá quando selecionar o lanche. Sugiro ir prezando pera padronização dos conceitos... tende a facilitar.

Dúvida:
 
O segredo para resolver qualquer problema é saber do que o problema se trata.
 
Enunciado:
 
Em qual momento estaria solicitando "quais"? Entende?
 
Imagine um cliente pedir um cachorro quente simples num restaurante, daí o garçom entrega um delicioso hambúrguer! "Oras! Meu consagrado, eu te pedi um cachorro quente. O que é isso?". 🙂
 
A tua dúvida seria apenas um detalhe para finalizar o algoritmo... mais abaixo exemplifico como poderia ficar. Vou aproveitar para citar como sugeriria criar esboços:
 
- como são 6 números inteiros, ou seja, um quantidade fixa de leitura, ficaria mais simples utilizar para, em vez de enquanto.
- para simplificar os testes, utilizar uma quantidade menor, como apenas 2.
 
algoritmo "Quantidade de pares e ímpares" //Crie um programa que leia 6 números inteiros e no final mostre quantos deles //são pares e quantos são ímpares. var i, numero : inteiro inicio para i de 1 ate 2 faca //testando com 2, depois muda para 6 leia(numero) fimPara fimAlgoritmo  
Daí só adicionar a verificação e exibir o resultado:
algoritmo "Quantidade de pares e ímpares" //Crie um programa que leia 6 números inteiros e no final mostre quantos deles //são pares e quantos são ímpares. var i, numero : inteiro qtdPares, qtdImpares : inteiro inicio qtdPares <- 0 //[1] qtdImpares <- 0 para i de 1 ate 2 faca //testando com 2, depois muda para 6 leia(numero) se (numero % 2 = 0) então qtdPares <- qtdPares+1 senao //[2] qtdImpares <- qtdImpares+1 fimSe fimPara escrevaL("Quantidade de pares : ", qtdPares:1) escrevaL("Quantidade de ímpares : ", qtdImpares:1) fimAlgoritmo //1. como está funcionando como um contador, precisa* inicializar as variáveis // obs.: o VisualG já zera automaticamente, mas vai acostumando com a boa prática //2. todo número inteiro OU é par, ou é ímpar. É uma dicotomia, logo, se não // for par, será necessariamente ímpar. Não precisa retestar  
 
 
 
Sobre "dizer quais são os pares e ímpares", uma forma seria simplesmente exibir:
 
algoritmo "Quantidade de pares e ímpares" //Crie um programa que leia 6 números inteiros e no final mostre quantos deles //são pares e quantos são ímpares. var i, numero : inteiro qtdPares, qtdImpares : inteiro inicio qtdPares <- 0 //[1] qtdImpares <- 0 para i de 1 ate 2 faca //testando com 2, depois muda para 6 escrevaL("Digite o número desejado") leia(numero) se (numero % 2 = 0) então qtdPares <- qtdPares+1 escrevaL("O número ", numero:1, " é par") senao //[2] qtdImpares <- qtdImpares+1 escrevaL("O número ", numero:1, " é ímpar") fimSe escrevaL() fimPara escrevaL() escrevaL("Quantidade de pares : ", qtdPares:1) escrevaL("Quantidade de ímpares : ", qtdImpares:1) fimAlgoritmo //1. como está funcionando como um contador, precisa* inicializar as variáveis // obs.: o VisualG já zera automaticamente, mas vai acostumando //2. todo número inteiro OU é para, ou é ÍMPAR. É uma dicotomia, logo, se não // for par, será necessariamente ímpar. Não precisa retestar  

 
 
Após testar direitinho, muda para 6 números e testa.
 
Ah! para facilitar os testes, é possível gerar números aleatórios. Uma forma simples e rápida seria assim:
 

 
Para parar, só desativar novamente.
 
Aí vai ajustando até ficar da forma que desejar.
 
ADENDO: lembrando que o enunciado NÃO pede quais são pares ou ímpares, portando não devem ficar na versão final.
 
Um outro exemplo:

 

@juniorbenz7, imaginando que está digitando respostas corretas, como citado pelo@Midori, deve ser algum problema com a versão do teu VisualG. Atualizei lá o tópico, veja lá.
 
 
Eu imagino que está utilizando a versão 3.0.7.0, pois como no teu código tem uns ";" ali na declaração de variáveis, na verão 2.5 nem iria rodar. Independente da versão, remova esses ";", pois não fazem parte da sintaxe do VisualG. Além disso, verificar os outros detalhes citados pelo @devair1010.

@nathalia.prado, dá uma olhada nesse tópico:
 
 
Adiantar mais um detalhezinho:
 
 
Se tem "divisão" no meio, a variável não pode ser inteiro. Dar primeiro uma olhada lá no tópico (sobre o possível problema com o escolha) e testa teu código. Para resolver essa questão do tipo numérico, mude para real, mas sugiro testa primeiro antes de ajustar!!! (para entender o erro).
 
 

Uma sugestão inicial é pesquisar. Exempo: https://www.google.com/search?q=copia+visualg
 
 
 
Sim. É preciso seguir as regras. No caso, seria seguir a sintaxe da linguagem.
 
Cada se tem um fimSe correspondente. A posição dos fimSe ficará de acordo também com a lógica do código. Veja:
 
se (opcao = 1) então //[1] se ((copia(sexo, 1, 1) = "m") e (altura <= 1.70) e (peso <= 83)) então //[2] escrevaL(" Adicionado à equipe 1 com sucesso") senao escrevaL(" Você não está dentro dos critérios para entrar na equipe 1") fimSe //final do segundo se senao se (opcao = 2) então //[3] se ((copia(sexo, 1, 1) = "f") e (altura <= 1.65) e (peso <= 70)) então //[4] escrevaL(" adicionado à equipe 2 com sucesso") senao escrevaL(" Você não está dentro dos critérios para entrar na equipe 2") fimSe //final do quarto se fimSe //final do terceiro se fimSe //final do primeiro se  
 
Para demonstrar, isolei o primeiro se/senao.
 
se (opcao = 1) então //[1] senao fimSe //final do primeiro se  
O segundo se está dentro do primeiro se.
O terceiro se está dentro do senão desse primeiro se. E o quarto se está dentro do terceiro.
 
Tem que ir treinando. Experimente reescrever o código acima 
 
IMPORTANTE:
 
 
 
Para postar um código no Fórum, utilize o botão CODE.

 
 
 
PS: ao pressionar Ctrl+G, o VisualG tenta dar um força na identação.

Complementado:
 
1# Sobre inicialização das variáveis
Faltou inicializar o TOTMED. Pois pau que dá em Chico dá em Francisco..., ou seja, é necessário manter a coerência no código. Já que iniciou um, teria que inicializar os outros caos semelhantes. Exemplo:
 
TOTMED <- 0.0  
Obs.: o VisualG já inicializa as variáveis globais automaticamente, ou seja, o desenvolvedor da "IDE" VisualG já programou o "compilador" para fazer isso por nós. As variáveis numéricas já ficam com "0" ao rodar o programa. Experimente criar um variável e depois já exibir o seu valor na tela. Desta forma, não seria necessário reinicializá-las com 0, certo?... Entretanto, como esse comportamento não é comum em outras linguagens de programação*, não vejo problemas em deixar assim. Seria o que chamaríamos de "boa prática".
 
 
 
2# Sobre cálculos de médias
Você está calculando a médias N vezes, mas só precisa calcular uma vez só!!! Não? Logo, o cálculo da média poderia ficar após o fimPara.
 
 
 
3# Sobre os casos
 
Creio que meio que dependeria do enunciado... Mas de um modo geral, o 0 seria nulo E seria múltiplo de 5 ao mesmo tempo, certo? Logo, o código estaria parcialmente correto... Só faltou considerar que o 0 também é par!
 
Daí, uma alternativa seria adicionar a verificação do zero também dentro do se do par, o que me pareceria deixar código redundante; outra poderia simplesmente deixa 3 se separados.
 
Exemplo:
se (N = 0) então TOTNUL <- TOTNUL + 1 fimSe se (N % 5 = 0) então TOTDIV <- TOTDIV + 1 fimSe se (N % 2 = 0) então TOTPAR <- TOTPAR + N fimSe  
Segue uma demonstração de resultado: (deixei com 3 valores para ficar mais simples)

 
PS: lembrando que o 0 é par. Daí, 10 + 0 = 10... Mas ele está sendo somando. 😄
 

@Beatriz Dorin, o código ficou muito bom! Apenas faltou contextualizar melhor... como também inserir o enunciado completo na postagem. 🙂
 
Adendo:
 
Como o 0 (zero) é o elemento neutro da adição, essas operações são desnecessárias... (modo sutil de dizer "inúteis", rs). Basta apagar essas duas linhas.
 
Ah! E no "nome do programa", pode inserir espaços... Ex.:
Algoritmo "Seletor de Pessoas"  

Basicamente está declarando as funções com uma sintaxe errada. Vejam um exemplo de como deveria ser aqui: https://www.apoioinformatica.inf.br/produtos/item/18-funcoes
 
Resumidamente: no VisualG, o retorno é pelo comando retorne (Ex.: retorne VERDADEIRO) . Diferente do Pascal (pai do VisualG), onde o retorno é na própria função mesmo. (Ex.: vazia := true).
 
Para ajudar a identificar melhor, remova o limpaTela() e veja que já dá problema na hora de empilhar. 🙂
 
Exemplo para o Adicionar():
funcao Adicionar (elemento: inteiro) : logico inicio se (Cheia()) então retorne FALSO senao topo <- topo + 1 pilha[topo] <- elemento retorne VERDADEIRO fimSe fimFuncao  
Exemplo para o Cheia():
funcao Cheia() : logico inicio se (topo >= LIM) então retorne VERDADEIRO senao retorne FALSO fimse fimFuncao  
Por aí vai.
 

"Um" erro? Aí não ajuda! Qual erro está dando? 🙂
 
 
Adendo:
Para adiantar... não lembro se o VisualG aceita "procedimento dentro de procedimento". Daí, deixe separados.. (não vai fazer diferença). Exemplo:
Algoritmo "Procedimentos" // Disciplina : Algoritmos // Professor : Livro Algoritmos // Descrição : Excercios do Livro // Autor(a) : Lorenzo Nunez // Data atual : 10/11/2022 Const fim = 10 Var vetA: vetor[1..fim] de caractere Procedimento Entrada Var i: inteiro Inicio para i de 1 ate fim faca escreva("Digite o",i,"º: ") //leia(vetA[i]) vetA[i] <- Carac(Asc("A") + RandI(9)+1) escrevaL(vetA[i]) fimpara Fimprocedimento Procedimento Troca (var a, b: caractere) Var x: caractere Inicio x <- a a <- b b <- x Fimprocedimento Procedimento Ordenacao Var i, j: inteiro Inicio para i de 1 ate fim-1 faca para j de i+1 ate fim faca se (vetA[i] > vetA[j]) então Troca(vetA[i],vetA[j]) fimse fimpara fimpara Fimprocedimento Procedimento Processamento Inicio Ordenacao() Fimprocedimento Procedimento Saida Var i: inteiro Inicio para i de 1 ate fim faca escreval("[",vetA[i]," ]") fimpara Fimprocedimento Inicio // Seção de Comandos, procedimento, funções, operadores, etc... Entrada() Processamento() Saida() Fimalgoritmo  

@dilucq, o % serve para retornar o resto. E é isso. 
 
Veja:
 
Se já saberia o resultado, para que serviria a conta? Entende?
 
Vamos lá: quanto é 6 / 3 ? Dá 2, com resto 0. Logo, 6 % 3 = 0. Fim
Quanto é 27/4? Dá 6, com resto 3. 27 % 4 = 3. Fim. 
 
O algoritmo está verificando se o número é ímpar... pois um número seria ímpar quando este é dividido por 2 e tem resto 1... Se se enquadrar nesse caso, diminui um do valor... para assim iniciar do primeiro par. Se digitou 9, vai ser ímpar, daí o valor vai para 8... após, exibir de 8 a 0...

Qual validação está fazendo?
 
Essa?

Qual o valor que vai está em nome, qual valor vai está em pesquisa? Se forem iguais e não estiver se alterando, vai dar ser igual mesmo.... 
 

Veja na minha postagem anterior um exemplo:
 

Você precisaria comparar o valor a ser pesquisado com cada uma dos valores no vetor.
 
Poste seu código completo e em qual parte está com dúvidas.
 

O operador lógico seria "=". Exemplo
 
se (cinema[fila,poltrona] = "O") entao  
Adendo:
 
Estas variáveis não estão sendo utilizadas. Pode remover. Se estava no código original, tente revisar com o facilitador... (Elas não são necessárias para o algoritmo que postou.)
 
Adendo 2:
 
Se o objetivo é simplesmente exibir como estão as poltronas (ocupadas ou livres), remova a linha:
 
 
Isso tá zerando toda as reservas...
 

@CaioSan, faltou declarar o vetor lá nas variáveis. Algo como:

 
clientes : vetor[1..3] de cadastroCliente  

Declarou:
 

Aí o VisualG apresenta problemas! 😁

Observe que o tipo é apenas "um registro", não um "vetor de registro", logo, lá no se onde deu erro não poderia ter os [].

Adendo: no VisualG não dá para definir um tipo "vetor de registros". Infelizmente. (No Pascal, pai do VisualG dá.)

@CaioSan, faltou declarar o vetor lá nas variáveis. Algo como:

 
clientes : vetor[1..3] de cadastroCliente  

Declarou:
 

Aí o VisualG apresenta problemas! 😁

Observe que o tipo é apenas "um registro", não um "vetor de registro", logo, lá no se onde deu erro não poderia ter os [].

Adendo: no VisualG não dá para definir um tipo "vetor de registros". Infelizmente. (No Pascal, pai do VisualG dá.)