Simon Viegas

@NaieleF, justamente. Provavelmente o exercício que postou seria voltado para outra "linguagem de programação", como a utilizada no Portugol Studio, que é um Portugol também, mas que é diferente da utilizada no VisualG.
 
Seria dessa lista de exercícios abaixo? 
 
Exercícios-de-Algoritmos-1-100.pdf
Fonte: https://www.cursoemvideo.com/wp-content/uploads/2020/10/Exercícios-de-Algoritmos-1-100.pdf
 
Se sim, lá cita o Portugol Studio mesmo...
 
Logo, caso queira utilizar o VisualG, utilizaria o repita, que é essencialmente a mesma coisa de um faca-enquanto (a diferença entre um e outro eu cito na minha postagem anterior).
 
 
Poderia ficar com algo como:
 
algoritmo "Exercicio.61" //PASSO 06 – REPETIÇÃO COM FAÇA ENQUANTO //61) Crie um programa que mostre na tela a seguinte contagem, usando a //estrutura “faça enquanto” 0 3 6 9 12 15 18 21 24 27 30 Acabou! var C: inteiro inicio C <- 0 repita escreva (C) C <- C + 3 ate (C > 30) escrevaL(" Acabou!") fimAlgoritmo  
Resultado:
 

 
Veja que se trata apenas da questão da escolha de uma sintaxe ("conjunto de regras que definem como escrever um código de programação de forma que o computador o compreenda"), ou seja, o VisualG seria "uma versão em português da linguagem de programação Pascal", onde no Pascal usam-se "while-do" e "repeat-until", ai no VisualG foi traduzido para "enquanto-faca" e "repita-ate" respectivamente. 😉
 
 
 
 
ADENDO:
 
Estrutura correta para o VisualG:
repita escreva (C) C <- C + 3 ate (C > 30)  
Possível estrutura caso o VisualG seguisse um mesmo padrão do Portugol Studio:
 
faca escreva (C) C <- C + 3 enquanto (C <= 30)  
Veja que a condição do enquanto é a negação da condição do até... o que antes era "<=", passou a ser ">"... e vice-versa. 
 
Poderia fazer assim, oh!:
 
algoritmo "Exercicio.61" //PASSO 06 – REPETIÇÃO COM FAÇA ENQUANTO //61) Crie um programa que mostre na tela a seguinte contagem, usando a //estrutura “faça enquanto” //0 3 6 9 12 15 18 21 24 27 30 Acabou! var C: inteiro inicio C <- 0 repita escreva (C) C <- C + 3 ate (não (C <= 30)) escrevaL(" Acabou!") fimAlgoritmo  
 
 
 
ADENDO 2:
 
Uma outra característica curiosa do VisualG é que ela insere automaticamente um espaço em branco antes de imprimir valores do tipo inteiro, veja:

 
Ou seja: o VisualG inseriu um espaço à esquerda, e você inseriu um espaço manualmente à direita, ficando assim com um espaço à esquerda lá no início, e com 2 espaços entre cada um dos números. (Está visualmente bagunçado... quando tiver contato com um tal de CSS você vai entender bem!!! kkkkkkkkk)
 
No meu código eu retirei o " ". Veja a diferença:

 
 
Uma forma de remover esses "espaços automáticos" seria utilizando uma formação com ":x", onde "x" seria o valor da quantidade de caracteres que quer reservar na impressão, exemplo:
 
repita escreva (C:1, " ") C <- C + 3 ate (C > 30))  
Resultado:
 

 
Nessa formatação, não tem espaço extra... Daí precisa novamente inserir o " ", caso contrário os números ficariam colados.
 
Agora ficou colado à esquerda e com apenas um espaço entre cada número.

Está recebendo o parâmetro, mas não está usando na ordenação... Poderia ficar com algo assim:
Para L de 1 ate tam_vet Faca Para A de 1 ate tam_vet - L Faca  
Daí o retorno também não seria necessário, pois está retornando o próprio valor original que foi recebido. Se não me engano isso seria uma Tautologia. Portanto, usaria um procedimento (que não tem retorno na próprio método), em detrimento de usar uma função (que é basicamente um procedimento que tem o tal retorno). 
 
PS: em linguagens mais modernas/comuns, não existe diferenciação entre procedimento e função, tudo é função... daí, as funções podem ou não retornar algo... quando não precisa retornar, comumente é definido com o "retorno void" (que significa vazio), ou seja, se o VisualG tivesse esse conceito, um procedimento seria algo assim:
 
funcao xpto () : vazio inicio fimFuncao  
 
 
Alguns pontos:

Por que especificamente "L" e "A"? Tem alguma correlação com algo?
 
Convencionalmente utilizam-se "i" e "j" como variáveis auxiliares para as iterações do para.
i, j, aux : inteiro  
Como sugerível acima, as variáveis e comando também são comumentes iniciadas em minúsculo. Dá uma pesquisada sobre camelCase... (Obs.: isso não é obrigatório, estaria relacionado mais a uma tentativa de seguir um suposto padrão geral.
 
Exemplo de código sem sub-rotina:
algoritmo "EXE4SUBROTINAS" //Para demonstrar o uso de sub-rotina com passagem de parâmetro, considere a //leitura de 10 valores em um vetor e os coloque em ordem crescente. A //ordenação deve ser executada por uma sub-rotina apropriada para este fim. var vet : vetor [1..10] de inteiro i, j, aux : inteiro inicio para i de 1 ate 10 faca escreva ("Digite um numero: ") leia(vet[i]:3) fimPara escreva ("Vetor original :") para i <- 1 ate 10 Faca escreva (vet[i]) fimPara escrevaL("") para i de 1 ate 9 Faca para j de 1 ate 10-i faca se (vet[j] > vet[j+1]) então aux <- vet[j] vet[j] <- vet[j+1] vet[j+1] <- aux fimSe fimPara fimPara escreva ("Vetor ordenado :") para i <- 1 ate 10 faca escreva (vet[i]:3) fimPara fimAlgoritmo
Para facilita os testes, pode deixar essa opção marcada:

 
Ai o próprio VisualG preenche com valores aleatório. Resultado ao pressionar F9:

 
 
 
Como já citado, por uma limitação técnica (o criador/desenvolvedor) simplesmente não implementou o recurso que possibilite passar vetores por parâmetro em procedimentos ou funções. É isso! O Pascal, "pai do VisualG", permite! Quem sabe vem numa próxima versão?
 
Daí... meio que o enunciado fica vago... Pois o vetor, necessariamente, terá que ser "passado" via variável global... e o tamanho do vetor também já é conhecido e fixo... já que está no próprio enunciado:
 
 
 
O código poderia ficar com algo assim:
 
O esqueleto do procedimento:
procedimento bubbleSort () inicio fimProcedimento https://pt.wikipedia.org/wiki/Bubble_sort
 
Aí só joga o conteúdo dentro:
para i de 1 ate 9 Faca para j de 1 ate 10-i faca se (vet[j] > vet[j+1]) então aux <- vet[j] vet[j] <- vet[j+1] vet[j+1] <- aux fimSe fimPara fimPara  
 
 
ADENDO IMPORTANTE:
Como boa prática, é interessante que "tudo que método use, ou venha por parâmetro, ou seja declarado dentro do método", ou seja, o vetor e o tamanho do vetor deveriam* vir por parâmetro (o primeiro o VisualG não permite, o segundo já foi proposto que é fixo), e as variáveis utilizadas no laços de repetições, declaradas dentro do método (criação de variáveis locais, que se separam das variáveis locais). Veja:
 
procedimento bubbleSort () var i, j, aux : inteiro inicio para i de 1 ate 9 Faca para j de 1 ate 10-i faca se (vet[j] > vet[j+1]) então aux <- vet[j] vet[j] <- vet[j+1] vet[j+1] <- aux fimSe fimPara fimPara fimProcedimento  
 
Daí só invocar o método onde precisa:
... escreva (vet[i]:3) fimPara escrevaL("") bubbleSort() escreva ("Vetor ordenado :") para i <- 1 ate 10 faca ...  
Olha como é interessante, uma sub-rotina seria basicamente um bloco de comandos em que se deu um nome... aí só invocar! Na prática, o VisualG vai "pular" para o trecho de código e ir executando linha a linha da mesma forma que se tivesse no corpo principal do código e depois volta para próxima linha depois de onde foi invocado. Como se fosse um "subprograma". O programa principal fica aguardando a sub-rotina terminar.
 
Código completo:
  
 
Aí, como parâmetros são necessário, poderia seguir a sugestão do @devair1010, ficaria algo assim:
procedimento bubbleSort (tam : inteiro) var i, j, aux : inteiro inicio para i de 1 ate tam-1 Faca para j de 1 ate tam-i faca se (vet[j] > vet[j+1]) então aux <- vet[j] vet[j] <- vet[j+1] vet[j+1] <- aux fimSe fimPara fimPara fimProcedimento  
Chama o método passando o parâmetro necessário.
... escrevaL("") bubbleSort(10) escreva ("Vetor ordenado :") ...  
Ou, ainda aprimorar o Bubble Sort(), criando um método específico para efetuar as trocas de posições:
algoritmo "EXE4SUBROTINAS" //Para demonstrar o uso de sub-rotina com passagem de parâmetro, considere a //leitura de 10 valores em um vetor e os coloque em ordem crescente. A //ordenação deve ser executada por uma sub-rotina apropriada para este fim. procedimento troca(var a, b : inteiro) var aux : inteiro inicio aux <- a a <- b b <- aux fimProcedimento procedimento bubbleSort () var i, j : inteiro inicio para i de 1 ate 10-1 Faca para j de 1 ate 10-i faca se (vet[j] > vet[j+1]) então troca(vet[j], vet[j+1]) fimSe fimPara fimPara fimProcedimento var vet : vetor [1..10] de inteiro i, j, aux : inteiro inicio para i de 1 ate 10 faca escreva("Digite um numero: ") leia(vet[i]) fimPara escreva ("Vetor original :") para i <- 1 ate 10 Faca escreva (vet[i]:3) fimPara escrevaL("") bubbleSort() escreva ("Vetor ordenado :") para i <- 1 ate 10 Faca escreva (vet[i]:3) fimPara fimAlgoritmo  
Ou seja: o procedimento troca() já satisfaria a exigência do enunciado ("uso de sub-rotina com passagem de parâmetro"). Mas tanto faz também deixar o método de ordenação também recebendo o parâmetro com o tamanho do vetor.
 
Ah! se o VisualG aceitasse vetores por parâmetro, a assinatura seria algo assim:
 
procedimento bubbleSort (var vet:vetor) Ou:
procedimento bubbleSort (var vet:vetor; tam:inteiro) Lembrando que isso NÃO FUNCIONA... pois ainda não foi implementando no VisualG. Já no Pascal, sim!... (não exatamente assim, mas funciona 😄)
 
PS: esse var determina que seria uma passagem de parâmetro do referência, ou seja, a variável local do método aponta diretamente para própria variável da qual foi passado o parâmetro, assim, tudo que for alterado dentro do método, será refletido na variável original... Funciona como um "ponteiro de memória". Já sem o var, o VisualG apenas "copia" o valor original e joga na variável local. Ao sair, a variável original fica intacta.
 
 
POSSÍVEL DÚVIDAS:
Oxente, por que declarou duas vezes as variáveis i e j? E pior, por que o VisualG não acusou que a variável foi "declarada mais de uma vez". Vide exemplo:
 

 
Resposta: as variáveis i e j foram declaradas "novamente" pois eventualmente o escopo do método precisa dessas variáveis, e como foi exposto no "ADENDO IMPORTANTE" mais acima, o objetivo é "isolar" o método do programa principal, ou seja, mesmo que seja modificado o laço de repetição no programa principal, o método não será comprometido, pois "tudo dentro do método ou veio de fora ou foi criado dentro do método"... 🙂
Por fim, foi utilizado também as mesmas letras, pois o VisualG permite. Poderia ser letras diferentes. Só se atente que são variáveis distintas! Tem a mesma nomenclatura, mas são de escopos diferentes. Veja:

 
Cada par de variável não tem nada a ver com o outro. Se não declarasse as variáveis locais, a sub-rotina iria utilizar a variáveis globais...
 
A magia vem aí... ao implementar uma método, você não precisa se preocupar se já existe uma variável com a mesma nomenclatura fora, nem muito menos vai se preocupar se está alterando um valor que não deveria... Por isso a importância do "isolamento". Isso vai ficar mais claro e medida que for implementando programas maiores... imagine a trabalheira que dá ficar "cuidado de cada variável". 
 

@jooao2607, o que pode ocorrer é que uma estrutura de repetição (como o For, While, Do While, For Each etc) possa ser mais prática ou adequada que a outra para um caso, mas meio que não existe uma regra específica obrigue utilizar uma coisa ou outra. Vai do contexto. Cada estrutura pode funcionar melhor ou pior que a outra. Ou pode também existir "padrões de implementações", ou seja, uma forma de fazer que seria mais comum no dia a dia dos programadores em geral...
 
Teria algum exemplo para contextualizar melhor a tua dúvida?

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.