Simon Viegas

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

Só complementando: como são "8 posições", seria de 0 a 7 (em detrimento de 0 a 8). Pequeno detalhe na digitação😄 .Ex.:
 
var numeros: vetor [0..7] de inteiro

Sobre:

Entendo que esse exercício seria bem básico. Meio que você precisaria atribuir um mesmo valor para todas as posições do vetor. Tentou fazer algo?
 
Então, o ideal é sempre tentar fazer de alguma forma... tentar fazer algo... sugeriria tentar fazer com o que já aprendeu com as aulas, e caso tenha muita dificuldade, achar exemplos prontos com temas semelhantes (uso de vetores) e entender o que foi feito lá nos exemplos e replicar (reescrever, nunca copiar) o código... ajustando de acordo com o seu próprio exercício.
 
Segue um exemplo pronto em VisualG 3.6.0.5:
algoritmo "Preenchimento de vetor" var numeros : vetor [0..7] de inteiro i: inteiro inicio para i de 0 ate 7 faca numeros[i] <- 999 fimPara //eu não sei se além de preencher é também para exibir... mas vai lá: para i de 0 ate 7 faca escreva (numeros[i]) fimPara escreval("") escreva (" ") para i de 0 ate 7 faca escreva (i, " " ) fimPara fimAlgoritmo  



Outra forma de preencher:
inicio numeros[0] <- 999 numeros[1] <- 999 numeros[2] <- 999 numeros[3] <- 999 numeros[4] <- 999 numeros[5] <- 999 numeros[6] <- 999 numeros[7] <- 999
Veja que essa forma é muito mais trabalhosa... "gasta muito mais linhas". No exemplo anterior, a combinação de vetores e laço de repetição (para) se sai bem mais prático.
 

Se for se basear com um dos códigos acimas, NÃO COPIE... redigite tudo. Vá fazendo modificações e testando.
 
Segue outro exemplo:
 
 
Qual a diferença? É que no VisualG os números são impressos com "um espaço à esquerda". Ao utilizar esses ":x" após o número, remove esse espaço. O valor de x (no caso 1 no exemplo acima), define que o VisualG deve reservar 1 espaço para exibir o número. Como assim? Se não conhece esse o comando, e quiser se aprofundar, faça testes. Insira outros valores após os ":" e tente entender como funciona. Por aí vai.

É um exercício de quê? Seria para criar um problema?

Por favor, poste também o enunciado completo.
Outra coisa: quais assuntos já estudou?

Creio que basicamente precisará de:
Estrutura de seleção Vetores Registros Estrutura de repetição
 

Olá, @Marigimenez.
 

Os masculino e feminino seriam valores, e não variáveis... Não se declara os valores (não dessa forma), pode usar diretamente onde precisa. Veja um exemplo abaixo:
 
algoritmo "Valor com desconto" var valorCompras, valorComDesconto : real nome, genero : caractere inicio escreva ("Digite seu nome : ") leia(nome) escreva ("Digite seu gênero (masculino ou feminino): ") leia(genero) escreva ("Digite o valor das suas compras : ") leia (valorCompras) se (genero = "feminino") entao valorComdesconto <- valorCompras - (valorCompras*0.05) escrevaL(nome, ", o valor das suas compra com desconto será de " , valorComDesconto:1:2) senao se (genero = "masculino") entao valorComdesconto <- valorCompras - (valorCompras * 0.13) escrevaL(nome, ", o valor da suas compras com desconto será de " , valorComDesconto:1:2) senao escrevaL("O gênero ", genero, "é inválido") fimSe fimSe fimAlgoritmo

 

Utilizando escolha, poderia ser algo assim:
 
escolha genero caso "feminino" valorComdesconto <- valorCompras - (valorCompras*0.05) escrevaL(nome, ", o valor das suas compra com desconto será de " , valorComDesconto:1:2) caso "masculino" valorComdesconto <- valorCompras - (valorCompras * 0.13) escrevaL(nome, ", o valor da suas compras com desconto será de " , valorComDesconto:1:2) outroCaso escrevaL("O gênero ", genero, "é inválido") fimEscolha  

@Marechal Barros, meio que fazendo um teste de mesa.
 
Anota as variáveis no papel. Ex.:
x = y = aux =
Daí a cada linha vai atualizando os valores de acordo com o algoritmo:

Linha 2 (após execução da declaração da variável):
x = 0 y = 0 aux = 0
Obs.: o VisualG cria as variáveis no computador e já define o valor padrão, de acordo com o tipo. Como são inteiro, ficarão com 0. A depender pode ignorar e considerar a partir do inicio.

Linha 4:
x = 3 //x recebeu 3 y = 0 aux = 0
Linha 5
x = 3 y = 4 //y recebeu 4 aux = 0  
Linha 6:
x = 3 y = 4 aux = 12 //aux recebeu 12, o resultado da multiplicação  
Linha 7
x = 3 y = 3 //y recebeu 3 (valor de x naquele momento) aux = 12  
Linha 8:
x = 3 y = 2 //y recebe o resultado da operação de módulo (resto da divisão) aux = 12
Como são poucas variáveis e são operações simples, meio que dá até para fazer de cabeça.

Siga a sugestão @Midori. Executa esse algoritmo no VisualG para visualizar melhor o resultado. Dica: vá pressionando F8  para  "Rodar passa a passo" e ir verificando os valores da variáveis na sessão da direita. Veja se linha a linha bate com o que postei acima.

@Marechal Barros, meio que fazendo um teste de mesa.
 
Anota as variáveis no papel. Ex.:
x = y = aux =
Daí a cada linha vai atualizando os valores de acordo com o algoritmo:

Linha 2 (após execução da declaração da variável):
x = 0 y = 0 aux = 0
Obs.: o VisualG cria as variáveis no computador e já define o valor padrão, de acordo com o tipo. Como são inteiro, ficarão com 0. A depender pode ignorar e considerar a partir do inicio.

Linha 4:
x = 3 //x recebeu 3 y = 0 aux = 0
Linha 5
x = 3 y = 4 //y recebeu 4 aux = 0  
Linha 6:
x = 3 y = 4 aux = 12 //aux recebeu 12, o resultado da multiplicação  
Linha 7
x = 3 y = 3 //y recebeu 3 (valor de x naquele momento) aux = 12  
Linha 8:
x = 3 y = 2 //y recebe o resultado da operação de módulo (resto da divisão) aux = 12
Como são poucas variáveis e são operações simples, meio que dá até para fazer de cabeça.

Siga a sugestão @Midori. Executa esse algoritmo no VisualG para visualizar melhor o resultado. Dica: vá pressionando F8  para  "Rodar passa a passo" e ir verificando os valores da variáveis na sessão da direita. Veja se linha a linha bate com o que postei acima.

@Marechal Barros, meio que fazendo um teste de mesa.
 
Anota as variáveis no papel. Ex.:
x = y = aux =
Daí a cada linha vai atualizando os valores de acordo com o algoritmo:

Linha 2 (após execução da declaração da variável):
x = 0 y = 0 aux = 0
Obs.: o VisualG cria as variáveis no computador e já define o valor padrão, de acordo com o tipo. Como são inteiro, ficarão com 0. A depender pode ignorar e considerar a partir do inicio.

Linha 4:
x = 3 //x recebeu 3 y = 0 aux = 0
Linha 5
x = 3 y = 4 //y recebeu 4 aux = 0  
Linha 6:
x = 3 y = 4 aux = 12 //aux recebeu 12, o resultado da multiplicação  
Linha 7
x = 3 y = 3 //y recebeu 3 (valor de x naquele momento) aux = 12  
Linha 8:
x = 3 y = 2 //y recebe o resultado da operação de módulo (resto da divisão) aux = 12
Como são poucas variáveis e são operações simples, meio que dá até para fazer de cabeça.

Siga a sugestão @Midori. Executa esse algoritmo no VisualG para visualizar melhor o resultado. Dica: vá pressionando F8  para  "Rodar passa a passo" e ir verificando os valores da variáveis na sessão da direita. Veja se linha a linha bate com o que postei acima.

@Pedroso90, uma forma seria verificar se as posições anteriores ao cadastro atual já contém o número de carro. Uma forma utilizando flag:
 
{$CODEPAGE UTF8} //permitir alguns caracteres especiais em alguns compiladores program EX1; type registroCarro = record num_carro: integer; nome_carro: string; ano_fab: integer; end; var carros_cadastro: array[1..6] of registroCarro; i, j, cont: integer; repetido: boolean; begin //Cadastrando os carros for i:= 1 to 6 do begin repeat write ('Digite o número do ' ,i, 'º carro: '); readln(carros_cadastro[i].num_carro); //Verifica se o número do carro é repetido repetido := FALSE; for j:=1 to i-1 do begin if (carros_cadastro[i].num_carro) = (carros_cadastro[j].num_carro) then begin repetido := TRUE; break; end; end; if (repetido) then writeln('Número de carro já cadastrado. Favor inserir um código novo') until not repetido; write ('Digite o nome do ', i, 'º carro: '); readln(carros_cadastro[i].nome_carro); write ('Digite o ano de fabricaçao do ', i, 'º carro: '); readln(carros_cadastro[i].ano_fab); end; end.
A flag seria a variável repetido..., ou seja, funcionando como uma "bandeira" que sinaliza algo, no caso que "o número do carro está repetido". O laço de repetição interno ajudando a varrer o vetor e alterando a flag se encontrar uma ocorrência. Posteriormente essa flag é usada para exibir ou não a mensagem e também verificar se vai repetir (o processo de leitura de um número e verificação de existência) ou não...

O "triângulo superior" seria os elementos acima da diagonal principal, correto?
 
O trecho estaria aqui:

Basicamente está escrevendo espaços onde NÃO é do triângulo superior, ou seja, onde "a posição da linha é maior ou igual a posição da coluna".
 
Simplificando (juntando as expressões):
para l <- 1 ate 4 faca para c <- 1 ate 4 faca se (l >= c) entao //[1] escreva (" ") senao escreva (mat [l,c] : 4 ) fimse fimpara escreval() fimpara  

Ou, se preferir, inverte a verificação... Escrevendo os valores apenas onde "a posição da linha é menor que a posição da coluna"
 
para l <- 1 ate 4 faca para c <- 1 ate 4 faca se (l < c) entao escreva (mat [l,c] : 4 ) senao escreva(" ") fimse fimpara escreval()  
O resultado será o mesmo.

Para o inferior é análogo.
 

@kalline, dei uma refatorada no código que postou. Vê se faz mais sentido agora.
 
algoritmo " RESERVAR ESPAÇOS NO CINEMA" var reservas: vetor [1..10] de inteiro cont1, numeroCadeira : inteiro ocupado: logico resposta: caractere inicio para cont1 <- 1 ate 10 faca escreva("[B", cont1:1, "]") fimpara escreval("") escreval("===================================================") escreval("RESERVAR CADEIRAS") escreval("===================================================") repita escreval("") escreva ("Reservar número da cadeira: B") leia(numeroCadeira) escreval("") ocupado <- FALSO para cont1 <- 1 ate 10 faca se (reservas[cont1]) = numeroCadeira entao ocupado <- VERDADEIRO fimSe fimPara se (não OCUPADO) entao reservas[numerocadeira] <- numerocadeira escreval("A cadeira B", numerocadeira:1, " foi reservada!!") senao escreval("ERRO: Lugar Ocupado") fimSe escreval("") escreva ("Quer reservar outra?[S/N] ") leia(resposta) ate (resposta = "n") fimAlgoritmo


Na hora de verificar se a poltrona está ocupada, não precisaria percorrer o vetor, pois a posição do vetor já é a posição da própria poltrona. Poderia ser algo assim:
 
Em vez de:
ocupado <- FALSO para cont1 <- 1 ate 10 faca se (reservas[cont1]) = numeroCadeira entao ocupado <- VERDADEIRO fimSe fimPara  
Fazer:
ocupado <- FALSO se (reservas[numeroCadeira] = numeroCadeira) entao ocupado <- VERDADEIRO fimSe
Daí, apenas precisa antes garantir que o número da cadeira é válido (no caso entre 1 e 10).
 
Se quiser resumir a verificação:
se (não (reservas[numeroCadeira] = numeroCadeira)) entao reservas[numerocadeira] <- numerocadeira escreval("A cadeira B", numerocadeira:1, " foi reservada!!") senao escreval("ERRO: Lugar Ocupado") fimSe  
 
 
 
Outro ponto é: qual a lógica de armazenar o valor da posição do vetor na própria posição no vetor? Está estranhamente redundante (sempre estará vazio ou estará com o valor da posição, ou seja, está binário...). Poderia utilizar qualquer coisa fixa mesmo... que funcione como uma flag.. como um "x", ou "OCUPADO", ou mesmo utilizar um vetor LOGICO. Exemplo:
 
algoritmo " RESERVAR ESPAÇOS NO CINEMA" var reservas: vetor [1..10] de LOGICO cont1, numeroCadeira : inteiro ocupado: logico resposta: caractere inicio para cont1 <- 1 ate 10 faca escreva("[B", cont1:1, "]") fimpara escreval("") escreval("===================================================") escreval("RESERVAR CADEIRAS") escreval("===================================================") repita escreval("") escreva ("Reservar número da cadeira: B") leia(numeroCadeira) escreval("") se (não reservas[numeroCadeira]) entao reservas[numerocadeira] <- VERDADEIRO escreval("A cadeira B", numerocadeira:1, " foi reservada!!") senao escreval("ERRO: Lugar Ocupado") fimSe escreval("") escreva ("Quer reservar outra?[S/N] ") leia(resposta) ate (resposta = "n") fimAlgoritmo  
 
 
Adendo: no VisualG por padrão o variáveis lógicas já são inicializados como FALSO, por isso que não precisaria inicializar o vetor, ou seja, o programa já vai rodar com as poltronas não reservadas (com FALSO).

@NOT DEAD, aparentemente é a falta de espaço após o Enquanto.
 
Dá uma testada aí nos avisa.
 
Dica:
Mantenha o código sempre indentado. No VisualG, pressione Ctrl+G para ganhar uma ajuda.
 
Segue um exemplo de código um pouco mais organizado:
algoritmo "sem nome" var n: inteiro inicio n <- 0 enquanto (n <= 0) faca escreval(n) n <- n+1 fimEnquanto fimAlgoritmo  
ADENDO:
Sugiro também utilizar a versão 3.0.6.5, que seria a mais estável.
Exemplo de fonte para download:
https://baixe.net/download/4313/visualg/
 

Cara... não sei naaada de Python praticamente. Mas tenta assim:
 
x1, x2, x3 = map(int, input().split()) lista = [x1, x2, x3] if (lista[0]) < (lista[1]): cont = lista[0] lista[0] = lista[1] lista[1] = cont print(lista)
Aqui funcionou... deve ser alguma coisa relacionada em como ler os dados... aí deve dar algum apresentando problemas na interpretação dos valores no if. Pode ser alguma codificação interna... não sei dizer.
 
Obs.: não faço ideia o que seja "map()" (tô na madrugada e estou com preguiça de pesquisar ). Apenas vi um exemplo e achei que faria sentido para leitura de inteiros... rs.
 
Vê se funciona e descobre o motivo (ou não). Ao mesmo tempo aguarda alguém que manja do Python para dar uma explicação melhor.
 
adicionado 2 minutos depois ADENDO: testei online. Estava com o mesmo erro. Lendo desta forma não deu mais.

Justamente. Faça o que ele pede... ele quer "quantos", não "quais". Basicamente é precisado se atentar ao problema, ou seja: aquilo que estaria sendo pedido no enunciado.
 
As alterações são simples... segue um exemplo de código:
 
programa { inclua biblioteca Util --> u funcao inicio() { inteiro num, cont_num = 1, qtd_acima_de_5 = 0, qtd_divisiveis_por_3 = 0 escreva("==================================\n") escreva("EXERCÍCIOS DE REPETIÇÕES ENQUANTO \n") escreva("==================================\n") enquanto(cont_num <= 20) { num = u.sorteia(0, 10) escreva("NÚMERO GERADO: ", num, "\n") se (num > 5) { qtd_acima_de_5++ } se (num % 3 == 0) { qtd_divisiveis_por_3++ } cont_num++ } escreva("\nQuantidade de números acima de 5 : ", qtd_acima_de_5, "\n") escreva("Quantidade de números divisíveis por 3: ", qtd_divisiveis_por_3, "\n") } }  

Justamente. Faça o que ele pede... ele quer "quantos", não "quais". Basicamente é precisado se atentar ao problema, ou seja: aquilo que estaria sendo pedido no enunciado.
 
As alterações são simples... segue um exemplo de código:
 
programa { inclua biblioteca Util --> u funcao inicio() { inteiro num, cont_num = 1, qtd_acima_de_5 = 0, qtd_divisiveis_por_3 = 0 escreva("==================================\n") escreva("EXERCÍCIOS DE REPETIÇÕES ENQUANTO \n") escreva("==================================\n") enquanto(cont_num <= 20) { num = u.sorteia(0, 10) escreva("NÚMERO GERADO: ", num, "\n") se (num > 5) { qtd_acima_de_5++ } se (num % 3 == 0) { qtd_divisiveis_por_3++ } cont_num++ } escreva("\nQuantidade de números acima de 5 : ", qtd_acima_de_5, "\n") escreva("Quantidade de números divisíveis por 3: ", qtd_divisiveis_por_3, "\n") } }  

Justamente. Faça o que ele pede... ele quer "quantos", não "quais". Basicamente é precisado se atentar ao problema, ou seja: aquilo que estaria sendo pedido no enunciado.
 
As alterações são simples... segue um exemplo de código:
 
programa { inclua biblioteca Util --> u funcao inicio() { inteiro num, cont_num = 1, qtd_acima_de_5 = 0, qtd_divisiveis_por_3 = 0 escreva("==================================\n") escreva("EXERCÍCIOS DE REPETIÇÕES ENQUANTO \n") escreva("==================================\n") enquanto(cont_num <= 20) { num = u.sorteia(0, 10) escreva("NÚMERO GERADO: ", num, "\n") se (num > 5) { qtd_acima_de_5++ } se (num % 3 == 0) { qtd_divisiveis_por_3++ } cont_num++ } escreva("\nQuantidade de números acima de 5 : ", qtd_acima_de_5, "\n") escreva("Quantidade de números divisíveis por 3: ", qtd_divisiveis_por_3, "\n") } }  

Justamente. Faça o que ele pede... ele quer "quantos", não "quais". Basicamente é precisado se atentar ao problema, ou seja: aquilo que estaria sendo pedido no enunciado.
 
As alterações são simples... segue um exemplo de código:
 
programa { inclua biblioteca Util --> u funcao inicio() { inteiro num, cont_num = 1, qtd_acima_de_5 = 0, qtd_divisiveis_por_3 = 0 escreva("==================================\n") escreva("EXERCÍCIOS DE REPETIÇÕES ENQUANTO \n") escreva("==================================\n") enquanto(cont_num <= 20) { num = u.sorteia(0, 10) escreva("NÚMERO GERADO: ", num, "\n") se (num > 5) { qtd_acima_de_5++ } se (num % 3 == 0) { qtd_divisiveis_por_3++ } cont_num++ } escreva("\nQuantidade de números acima de 5 : ", qtd_acima_de_5, "\n") escreva("Quantidade de números divisíveis por 3: ", qtd_divisiveis_por_3, "\n") } }  

@Marcus V Santos, além dos prints, poste também o texto completo do código para facilitar as análises e também indexação dos motores da internet.
 
Em relação ao erro, utilize um par de aspas duplas.
 
Ex.:
Modo certo:
escreval("Texto entre duas aspas duplas")  
 
Modo errado:
escreval(''Texto entre dois pares de aspas simples'')  

@Marcus V Santos, além dos prints, poste também o texto completo do código para facilitar as análises e também indexação dos motores da internet.
 
Em relação ao erro, utilize um par de aspas duplas.
 
Ex.:
Modo certo:
escreval("Texto entre duas aspas duplas")  
 
Modo errado:
escreval(''Texto entre dois pares de aspas simples'')  

@Marcus V Santos, além dos prints, poste também o texto completo do código para facilitar as análises e também indexação dos motores da internet.
 
Em relação ao erro, utilize um par de aspas duplas.
 
Ex.:
Modo certo:
escreval("Texto entre duas aspas duplas")  
 
Modo errado:
escreval(''Texto entre dois pares de aspas simples'')  

@dve, você precisaria assimilar melhor o problema. Daí tentar criar um algoritmo a partir do que entendeu.
 
Tente entender que o "assimilação" não tem relação com o VisualG. Está mais voltado para "interpretação de textos" mesmo. O VisualG seria apenas uma ferramenta que tentaria automatizar o que você entendeu...
 
 
Vamos tentar destrinchar o enunciado:
 
 
Para o [1], estaria meio que claro... ele quer que obtenha os dados de alguma forma. No contexto do problema seria "via teclado", os dados informados pelo usuário... Mas poderia ser de qualquer forma... por um formulário no Google; por um arquivo de texto etc., entende?  A a "essência" é que precisa obter os dados...
 
Basicamente no VisualG seria o que você fez:
escreva ("Digite um número: ") leia(numero)  
 
Para [2], ele quer que faça o [1] até que determinada condição seja feita. Como você deve está estudando, o para seria mais voltado para "loops com quantidade pré-determinadas", mas que não é o caso... ou seja: talvez seria mais adequado utilizar o enquanto ou o repita.
 
Para o [3], ele quer que, após o [2], apresente "informações". No caso, os dados serão o [4] e o [5]... Ou seja: em algum momento seria necessário processar os dados de [1] para obter o [4] e [5].
 
Segue um algoritmo parcial:
 
repita   leia um número atualize a quantidade de entrados adicione o valor do número a soma total dos números até número igual a 0 calcule a média exiba a quantidade de números entrados exiba a média dos entrados  
Um código poderia ser mais ou menos assim:
Obs.: o algoritmo inicial e código estão incompletos... ainda tem problemas, sendo necessário reanalisar e complementar.
 
algoritmo "Quantidade de números e a média deles" var numero: real somaNumeros: real qtdEntrados: inteiro media: real inicio repita ///[2] escreva ("Digite um número positivo (ou 0 para sair): ") leia(numero) //[1] //atualiza a quantidade de números entrados qtdEntrados <- qtdEntrados+1 //atualiza a soma dos números entrados somaNumeros <- somaNumeros+numero ate (numero = 0) //fim [2] //[3] media <- somaNumeros/qtdEntrados escreval("Quantidade de entrados:", qtdEntrados) //[4] escreval("Média dos entrados :", media) //[5] //fim [3] fimAlgoritmo  
Falta por exemplo inserir uma lógica para tratar os números negativo e cuidar da soma dos números (ele está contabilizando o 0, mas não deveria [assim como não deve contabilizar os negativos]).
 
Por aí vai

Provavelmente teria algo a ver com o gerenciamento de memória no VisualG.
 
Nos testes aqui, no primeiro loop, quando c está igual a 1, o programa estaria retornando o valor que está atribuído a t2...
 
Para o restante do loop estaria retornando o que seria o "último valor da sequência". Meio que está apontando para o "suposto enderenço de memória do retorno da função"...  o que seria a "variável fibonacci".
 
Tipo, lá quando você colocou:
T3 <- fibonacci(t1,t2,t3)
Perceba que a própria função funciona como uma variável.. você podendo "copiar o valor dela", que no caso seria o "tal retorno da função"...
 
Beleza. Vamos demonstrar.. 
 
Se for a primeira vez que executou o código, provavelmente vai aparecer assim:
 

 
Esse primeiro 0 é o valor de t1. O 1 é o valor que está em t2. Vou mudar para 7, veja:
 

 
 
Agora vou inserir o retorne e o var:
 

 

 
Observe o valor final deu, eventualmente, 89. Esse foi o "último retorno". O que estaria lá no endereço que seria do retorno da função.
 
 Daí, ao executar novamente o seu "código incompleto". (Basta remover o retorne, ou seja: parar de atualizar o valor do retorno.)
 

 
Oh! Lá! Esse primeiro 0 é o valor de t1, o 1 é do t2 e o restante seria o tal "valor que está lá na memória"... um "lixo da execução anterior". O VisualG estaria sempre retornando o último valor que está lá onde seria o retorno da função.
 
 
Resumindo: o motivo não seria tão importante. D
se (op = "sair") entao fimAlgoritmo fimSe e qualquer modo esse código não era nem para rodar, já que a função está sem retorno.
 
Veja: existe uma diferença entre "erro de lógica", como por exemplo não colocar o var e a conta dar errada. E o "erro de sintaxe", como no exemplo de de não colocar o retorne. Para esse último, o "compilador" nem deveria deixar rodar... apenas acontece que o VisualG não compila o código, ele sequer é capaz de verificar que tem esse problema (de não ter o retorne)... são coisas da "IDE".
 
 
 
 
Adendo 1:
 
Como citado, a necessidade ou não do var estaria ligado apenas a lógica. Isso não tem influência direta no erro do que está acontecendo.
 
 
 
Adendo 2: 
 
@Matheus Rodrigues, essa constatação faz até sentido no mundo da programação, mas não teria relação com o problema, pois o VisualG não é Case Sensitive.
 
 
 
RESUMINDO:
A falta do retorne na função está causando um bug no VisualG. Entendo que isso NÃO seria uma "forma de implementar" códigos. O retorne é um requisito. Conceitualmente o programa não poderia ficar assim, mesmo que esse recurso (ficar sem o retorne) funcionasse para alguma lógica... Seria um glitch. (Ou algo do tipo.)
 
Só para deixar claro: imagine que por alguma sorte absurda o código com erro tivesse pegando o valor de C para o retorno. O resultado do cálculo poderia dar certo, mas..... mesmo assim estaria ERRADO. Pois necessariamente teria que vir do explicitamente pelo retorne.
 
 
 
 
PS:
Outro exemplo de glitch:
 
   se (op = "sair") entao      fimAlgoritmo    fimSe  
Se utilizar algo do tipo no programa iria funcionar, mas essa sintaxe não existe! Não poderia "utilizar o fimAlgoritmo" para forçar o encerramento. O código "roda" porque o VisualG é "bugado"/"tem limitações"... 
 

@RenanMusico, o segredo é: sempre mantenha seu código indentado. Vide:
 
programa { inclua biblioteca Texto --> txt inclua biblioteca Util --> ut inclua biblioteca Arquivos --> arq funcao inicio() { jogo() } funcao jogo() { inteiro indice, auxiliar, tamanho cadeia entrada cadeia linha, letra,formar_palavra[100] logico acertou, repetiu inteiro acertos,erros inteiro arquivo = arq.abrir_arquivo("./jogo.txt", arq.MODO_LEITURA) linha = arq.ler_linha(arquivo) tamanho = ut.numero_elementos(formar_palavra) acertos = tamanho erros = 6 para(arquivo = 0; arquivo < tamanho; arquivo++) { formar_palavra[arquivo]= "_" } enquanto (acertos > 0 e erros >0) escreva("\nDigite Uma Letra","\nSuas tentativas restantes são:",erros) para (arquivo = 0; arquivo < tamanho; arquivo++) { escreva(formar_palavra[arquivo]) } escreva(" :") leia(letra) acertou = falso repetiu = falso para(arquivo = 0; arquivo < tamanho; arquivo++) { se(letra == formar_palavra[arquivo]) { se(formar_palavra[arquivo] == letra) { repetiu = verdadeiro } acertou = verdadeiro formar_palavra[arquivo] = letra acertos-- } } se(repetiu == verdadeiro) { escreva("\nVocê ja digitou essa letra\n\n") } senao se(acertou == verdadeiro) { escreva("\nVocê acertou continue !!!\n\n") } senao { erros-- escreva("\nVocê errou tente novamente\n\n") } se(acertos == 0) { escreva("\nParabéns você acertou a palavra '-' ") para(arquivo = 0; arquivo < tamanho; arquivo++) { escreva(formar_palavra[arquivo]) } } se(erros == 0) { escreva("\nQue pena não foi dessa vez tente a sorte novamente\n\n") } arq.fechar_arquivo(arquivo) } }  
Oh! Aqui:

 
Você colocou para ficar repetindo essa linha...
 
 

Poste o código completo do que já conseguiu fazer e informe em qual ponto está travado...
 
 
Sobre:
 
Basicamente vai precisar de estruturas de seleção / desvio condicional, ou em outras palavras, de alguns se.
 
Veja:
 
Primeiro você obtém os dados necessários:
 
 
Daí faz as verificações:
 
Perceba que a primeira coisa para resolver um problema é entender o problema. No mundo real, quando é que você tomaria multa se fosse seguir os critérios do enunciado?
 
Pense aí... é quando "quando você ultrapassar o limite máximo". Se o limite é 100, e você passar a 101, você estaria sujeito a tomar multa. Entre 0 e 100 não, certo? Então, ai ele estaria delimitando essa faixa entre 100 e 110 (não inclusos*), ou seja: você vai levar multa e vai tomar essa multa em específico.
 
Traduzindo para VisualG, seria algo como:
 
se (velocidadeDoMotorista > velocidadeMaxima) E (velocidadeDoMotorista < velocidadeMaxima+10) entao valorMulta <- 50 fimSe  
Ou seja: num limite de 100km/h, se passar a 100km/h não entra nessa categoria (na prática não vai definir o valor da multa). Se passar a 101 entra na categoria. Se passar a 109 também. Já se passar a 110 não entra! (Pois estaria fora dessa categoria.)
 
Pronto... daí define uma próxima categoria. Ex.:
 
se (velocidadeDoMotorista >= velocidadeMaxima+10) E (velocidadeDoMotorista < velocidadeMaxima+30) entao valorMulta <- 100 fimSe  
 
A interpretação deixo contigo... caso necessário, faço ajustes e também implemente a terceira categoria...
 
Por aí vai.
 
Qualquer dúvida é só postar.
 
Lembre-se de postar o código atual completo e em qual parte está com dúvidas.
 
 

O procedimento está definido para receber 1 parâmetro (um texto). Lá no programa principal está passando 2. São assinaturas diferentes.
 
 Ajuste a assinatura do procedimento, exemplo:
 
procedimento Gerador(msg: caractere; qtd: inteiro)
Aí, coloque apenas para exibir o valor de qtd na tela... apenas para ver se está funcionando.
 
Após, você ira criar um laço de repetição que vai fazer o msg ser impresso qtd vezes.
 

Olá.
 
Cada vetor tem o seu próprio "contador". Bastaria utilizar. Algo como:
 
se (idades[cont] >= 0) e (idades[cont] < 18) entao CM <- CM + 1 menores[CM] <- idades[cont] fimSe  
 
escreva ("Menores: ") para cont <- 1 ate CM faca escreva (menores[cont],", ") fimSe fimPara