Simon Viegas

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  

Sobre:
 
@devair1010, creio que não tenha problema fazer isso... Vai funcionar normalmente e sem erros lógicos (eu acho, rs).
 
Um pouco mais sobre:
 
 
 
@joshuayuuki, sobre:
 
 
Tá! Mas está travado em qual ponto? Qual a sua dificuldade? Está dando algum erro ou alguma parte não está funcionando?
 
Fazendo uma analogia... seria como chegar com um carro numa oficina e dizer pro mecânico: "Meu carro está com problema. Tome aqui a chave". Entende?
 
 
Para tentar adiantar... ainda fazendo uma analogia, vou passar um scanner para ver se acho algo:
 
Vamos lá:
 
Um probleminha que já encontrei seria esse:
 

 
 
Esse comando não deveria servir para esse propósito de "finalizar o programa na marra"... Entendo que o programa deveria seguir o seu fluxo natural. O programa não dá erro simplesmente porque o VisualG é problemático .
 
Além do mais a estrutura do código já está correta... basta apagar essa linha!!! 
 
Veja:

 
Observe que, ao utilizar o "fimEnquanto" o programa "estoura" na hora... logo, essa condição acima nunca seria verificada, o que por si só não faz sentido. (Acaba se tornando uma tautologia para o contexto - sempre o resultado será verdadeiro.)
 
Ah! a expressão aí no enquanto vai funcionar de boa, mas mesmo assim ela está ERRADA. Deveria ser E no lugar do OU.
 
ADENDO: a não ser que tenha alguma literatura ou alguém com algum argumento mais plausível, esse comando fimAlgoritmo só deveria ser usando uma vez no programa.
 
 
 
Um outro problema é na hora de listar... o código está exibindo todo o vetor*, mas acho que deveria exibir apenas os elementos cadastrados, ou seja: se cadastrou 2, só deveria aparecer 2 valores e não os 2 mais 0 e 0.
 
*vetor = nome mais simples para a tal da "estrutura homogênea"
 

Sobre:
 
O que significa FIFO? Então, não me faz muito sentido querer ordenar! Concorda?
 
 
Sobre:
 
O método de ordenação contido nos códigos NÃO é um Bubble Sort. Dê também uma revisada.
 
Sobre:
 
Qual versão do VisualG está utilizando?
 

Falta as " (aspas duplas) para os caracteres a serem comparados. Exemplo:
 
se (sexo = "F") e (idade >= 25) e (idade <= 30) e (cabelo = 3) entao mulher <- mulher + 1 fimSe  

@Felipe_Fernandes, você está utilizando um sintaxe não válida para VisualG. Veja:
 
 
 
O comando var não usa o inicio... Seria algo assim:
algoritmo "variáveis especiais" var numerico:cep,fone,data_nasc,rg,grauo literal:nome,cidade,uf,pai,mae    
Certo?
 
Aí entra outro ponto: no VisualG, o tipo vem depois.. e não antes. Seria algo assim:
algoritmo "variáveis especiais" var cep,fone,data_nasc,rg,grau:numerico nome,cidade,uf,pai,mae:literal  
Certo?
 
Aí entra outro ponto: numerio e literal não são tipo usado no VisualG. Aqui usaria respectivamente inteiro e caractere. Seria algo assim:
algoritmo "variáveis especiais" var cep,fone,data_nasc,rg,grau:inteiro nome,cidade,uf,pai,mae:caractere  
Por aí vai...
 
Esse código aqui já seria uma "correção" do seu código:
 

Olá.
a média só precisa ser calculada uma vez (fora do loop); feche o se da maioridade. O fimse está fora do lugar; tem variáveis declaradas que não foram usadas. Precisa dar uma reorganizada na lista  
ADENDO:
Acredito que esta estrutura não seja válida:
 
 
O comando fimAlgoritmo deve ser inserido apenas no fim do programa... no caso, o programa não dá erro seria simplesmente um bug.
 
 
 

Sobre:
 
Então provavelmente o erro está nessa declaração. No caso, não existe (ou não é mais utilizado) literal em VisualG. O mais correto seria utilizar caractere em seu lugar.
 
Segue referência básica:
https://www.apoioinformatica.inf.br/produtos/visualg/linguagem/item/6-tipos-de-dados
 
 
 
Adendo: sugiro utilizar a versão 3.0.6.5 do VisualG. É a versão mais estável.
 
Link
https://baixe.net/visualg
 
Link direto (pois tem uma propagandas confusas no site)
https://baixe.net/dwn/4/125/VISUALG3_REV60.rar
 
 

Você colocaria tudo que quer que repita dentro do repita... exemplo:
 
algoritmo "victor" var menos25, mais50, idade: inteiro inicio repita escreva("Idade: ") leia(idade) se (idade >= 0) e (idade < 25) entao menos25 <- menos25 + 1 fimSe se (idade > 50) entao mais50 <- mais50 + 1 fimse ate idade < 0 escreval("Menores que 25: ", Menos25) escreval("Maiores que 50: ", Mais50) fimAlgoritmo  
Se quiser que fique exibindo a resposta, coloca a resposta dentro do laço também... aí vai dos requisitos e do gosto.
 
O VisualG vai interpretando linha a linha do código... é como nossa leitura e escrita: da esquerda para direita, de cima para baixo. Aí, o comando repita vai funciona basicamente como um "marcador de posição"... aí, lá no ate vai verificar a condição, se for FALSO, o VisualG vai voltar para linha do repita. Se VERDADEIRO, vai para próxima linha após o ate.
 
O repita é como o se. A diferença é que nesse último, se VERDADEIRO, ele executa o que está dentro do se, se FALSO, pula para depois linha o o fimSe (ou para o senao, caso tenha)... ou seja: só muda "para onde a execução pula" .
 
Dicas:
pressione Ctrl+G para identar o código; vá pressionando F8 para ir acompanhando linha a linha; no lado direito do VisualG dá para acompanhar os valores que estão nas variáveis.

1#
Sobre:
 
Essa sintaxe não existe. Simplesmente apague essa linha.
 
 
 
2#
Sobre:
 
Essa sintaxe do senao está também incorreta. Não existe "senao/entao". De um modo geral, veja exemplos na internet. (Mas eu vou postar uma base mais pro fim.)
 
 
 
3#
No mesmo código do 2# você está comparando um valor real com o caractere... tá achando que está programando em JavaScript, amigo? . Não pode fazer isso. Uma alternativa seria utilizar uma variável do tipo caractere, veria se estaria representando um número ou não de alguma forma, aí converteria para real se precisasse. De qualquer sorte, é melhor pensar em outra forma...
 
 
 
4#
Segue um resumindo do código sem a raiz:
 
algoritmo "Calculadora" var n1, n2: real met: caractere inicio escreval("Digite seu primeiro número ou operação") leia(n1) escreval() escreval("Agora digite seu segundo número") escreval() leia(n2) escreval() escreval("Agora escolha uma operação") escreval() leia(met) se met = "+" entao escreval(n1+n2) senao se met = "-" entao escreval(n1-n2) senao se met = "*" entao escreval(n1*n2) senao se met = "/" entao escreval(n1/n2) senao se met = "^" entao escreval(n1^n2) fimSe fimSe fimSe fimSe fimSe fimAlgoritmo  
Perceba que o senao fica dentro do se. Se a condição resultar em VERDADEIRO, executa o que está entre o entao e o senao e pula o senao. Caso seja FALSO, pula o trecho entre o entao e o senao e executa o senao.
 
 
 
5#
Para tentar ajudar... segue um exemplo alternativo:
 
algoritmo "Calculadora" var n1, n2: real met: caractere inicio escreval() escreval("Digite seu primeiro número") escreval() leia(n1) escreval() escreval("Agora escolha uma operação") escreval() leia(met) se met = "raiz" entao escreval(RaizQ(n1)) senao escreval() escreval("Agora digite seu segundo número") escreval() leia(n2) escreval() se met = "+" entao escreval(n1+n2) senao se met = "-" entao escreval(n1-n2) senao se met = "*" entao escreval(n1*n2) senao se met = "/" entao escreval(n1/n2) senao se met = "^" entao escreval(n1^n2) fimSe fimSe fimSe fimSe fimSe fimSe fimAlgoritmo  
Dica: pressione Ctrl+G para indentar o código. Se fica torto, é porque tem algo fora do lugar.
 

Olá. Só complementando:
 
Sobre:
 
Creio que a maioria das linguagens de programação o uso de "()" NÃO é obrigatório... entretanto, pode haver diferenças de sintaxes entre uma "linguagem de programação" e outra. Por exemplo: no Portugol Studio, que usa um "Portugol", não precisa usar "()" e iria funcionar corretamente. Já no Pascal, que é o "pai" do VisualG", também não é obrigatório usar o "()", mas a lógica não iria funcionar porque a comparação seria feita de outra forma e daria erro de incompatibilidade de variáveis, ou seja: o uso de "()" no Pascal seria para ajustar a lógica, não porque é "obrigatório". Já no VisualG, independentemente da lógica é obrigatório o uso de "()", isso ocorre, creio eu, por uma limitação da linguagem (o desenvolvedor não implementou ainda para funcionar). No C# também sei que não é obrigatório o "()" para separar as sentenças, mas não sei como se comporta... pode ser de uma outra outra forma (teria que ver a documentação ou fazer testar).
 
RESUMINDO:
Na dúvida, use o "()" como citado pelo @devair1010.
 
Outra forma seria assim:
se ((imc < 16) ou (imc > 40)) entao //esses "()" mais externos NÃO são obrigatórios no VisualG, mas //em outras "linguagens" costumam ser... como no caso do Portugol Studio  
 
 
Vamos ao enunciado... lá tem algo como: 
 
Ou seja: ele quer a expressão que faça as duas coisas: calcular e imprimir, e quer apenas os casos extremos da tabela (primeiro e último caso)... Se observar, todos calculam, daí precisa "apenas" ver a que calcula corretamente... existem 3 (três) formas de calcular no exercício e delas duas dão o mesmo resultado, portanto servem para calcular o IMC...
 
Esta serve:
 
e esta serve:
 
 
Já esta NÃO serve:
 
ADENDO 1: o VisualG meio que segue a regra do "PEMDAS". Daí, cada uma dessas 3 fórmulas efetuará um cálculo diferente, entretanto a primeira e a segunda são equivalentes.
 
Entretanto, essa segunda que serve, é a que fica mais "semântica", ou seja: fica uma representação mais próxima da fórmula geral do IMC.
 
Pronto, sobraram apenas as opções B e E, daí, para dar o resultado desejado ("apenas casos extremos"), o valor precisa ser OU menor que 16 OU maior que 40, logo seria a letra B.
 
ADENDO 2: ainda complementando, não poderia ser a E, pois para a condição ser verdadeira, uma mesma variável teria que ter 2 valores ao mesmo tempo, o que torna a verificação uma contradição (nunca será verdadeiro, já que "nunca" terá 2 valores, logo "nunca" sendo maior e menor ao mesmo tempo).
 
 
 
Apenas para demonstração...
 
Vejam o ocorre no VisualG 3.6.0.5 (considerável a versão mais estável):

 
 
Testei no VisualG 2.5 também:

 
 
Já no Portugol Studio funciona de boa:
 

 
Falou

Olá. Só complementando:
 
Sobre:
 
Creio que a maioria das linguagens de programação o uso de "()" NÃO é obrigatório... entretanto, pode haver diferenças de sintaxes entre uma "linguagem de programação" e outra. Por exemplo: no Portugol Studio, que usa um "Portugol", não precisa usar "()" e iria funcionar corretamente. Já no Pascal, que é o "pai" do VisualG", também não é obrigatório usar o "()", mas a lógica não iria funcionar porque a comparação seria feita de outra forma e daria erro de incompatibilidade de variáveis, ou seja: o uso de "()" no Pascal seria para ajustar a lógica, não porque é "obrigatório". Já no VisualG, independentemente da lógica é obrigatório o uso de "()", isso ocorre, creio eu, por uma limitação da linguagem (o desenvolvedor não implementou ainda para funcionar). No C# também sei que não é obrigatório o "()" para separar as sentenças, mas não sei como se comporta... pode ser de uma outra outra forma (teria que ver a documentação ou fazer testar).
 
RESUMINDO:
Na dúvida, use o "()" como citado pelo @devair1010.
 
Outra forma seria assim:
se ((imc < 16) ou (imc > 40)) entao //esses "()" mais externos NÃO são obrigatórios no VisualG, mas //em outras "linguagens" costumam ser... como no caso do Portugol Studio  
 
 
Vamos ao enunciado... lá tem algo como: 
 
Ou seja: ele quer a expressão que faça as duas coisas: calcular e imprimir, e quer apenas os casos extremos da tabela (primeiro e último caso)... Se observar, todos calculam, daí precisa "apenas" ver a que calcula corretamente... existem 3 (três) formas de calcular no exercício e delas duas dão o mesmo resultado, portanto servem para calcular o IMC...
 
Esta serve:
 
e esta serve:
 
 
Já esta NÃO serve:
 
ADENDO 1: o VisualG meio que segue a regra do "PEMDAS". Daí, cada uma dessas 3 fórmulas efetuará um cálculo diferente, entretanto a primeira e a segunda são equivalentes.
 
Entretanto, essa segunda que serve, é a que fica mais "semântica", ou seja: fica uma representação mais próxima da fórmula geral do IMC.
 
Pronto, sobraram apenas as opções B e E, daí, para dar o resultado desejado ("apenas casos extremos"), o valor precisa ser OU menor que 16 OU maior que 40, logo seria a letra B.
 
ADENDO 2: ainda complementando, não poderia ser a E, pois para a condição ser verdadeira, uma mesma variável teria que ter 2 valores ao mesmo tempo, o que torna a verificação uma contradição (nunca será verdadeiro, já que "nunca" terá 2 valores, logo "nunca" sendo maior e menor ao mesmo tempo).
 
 
 
Apenas para demonstração...
 
Vejam o ocorre no VisualG 3.6.0.5 (considerável a versão mais estável):

 
 
Testei no VisualG 2.5 também:

 
 
Já no Portugol Studio funciona de boa:
 

 
Falou

Olá. Só complementando:
 
Sobre:
 
Creio que a maioria das linguagens de programação o uso de "()" NÃO é obrigatório... entretanto, pode haver diferenças de sintaxes entre uma "linguagem de programação" e outra. Por exemplo: no Portugol Studio, que usa um "Portugol", não precisa usar "()" e iria funcionar corretamente. Já no Pascal, que é o "pai" do VisualG", também não é obrigatório usar o "()", mas a lógica não iria funcionar porque a comparação seria feita de outra forma e daria erro de incompatibilidade de variáveis, ou seja: o uso de "()" no Pascal seria para ajustar a lógica, não porque é "obrigatório". Já no VisualG, independentemente da lógica é obrigatório o uso de "()", isso ocorre, creio eu, por uma limitação da linguagem (o desenvolvedor não implementou ainda para funcionar). No C# também sei que não é obrigatório o "()" para separar as sentenças, mas não sei como se comporta... pode ser de uma outra outra forma (teria que ver a documentação ou fazer testar).
 
RESUMINDO:
Na dúvida, use o "()" como citado pelo @devair1010.
 
Outra forma seria assim:
se ((imc < 16) ou (imc > 40)) entao //esses "()" mais externos NÃO são obrigatórios no VisualG, mas //em outras "linguagens" costumam ser... como no caso do Portugol Studio  
 
 
Vamos ao enunciado... lá tem algo como: 
 
Ou seja: ele quer a expressão que faça as duas coisas: calcular e imprimir, e quer apenas os casos extremos da tabela (primeiro e último caso)... Se observar, todos calculam, daí precisa "apenas" ver a que calcula corretamente... existem 3 (três) formas de calcular no exercício e delas duas dão o mesmo resultado, portanto servem para calcular o IMC...
 
Esta serve:
 
e esta serve:
 
 
Já esta NÃO serve:
 
ADENDO 1: o VisualG meio que segue a regra do "PEMDAS". Daí, cada uma dessas 3 fórmulas efetuará um cálculo diferente, entretanto a primeira e a segunda são equivalentes.
 
Entretanto, essa segunda que serve, é a que fica mais "semântica", ou seja: fica uma representação mais próxima da fórmula geral do IMC.
 
Pronto, sobraram apenas as opções B e E, daí, para dar o resultado desejado ("apenas casos extremos"), o valor precisa ser OU menor que 16 OU maior que 40, logo seria a letra B.
 
ADENDO 2: ainda complementando, não poderia ser a E, pois para a condição ser verdadeira, uma mesma variável teria que ter 2 valores ao mesmo tempo, o que torna a verificação uma contradição (nunca será verdadeiro, já que "nunca" terá 2 valores, logo "nunca" sendo maior e menor ao mesmo tempo).
 
 
 
Apenas para demonstração...
 
Vejam o ocorre no VisualG 3.6.0.5 (considerável a versão mais estável):

 
 
Testei no VisualG 2.5 também:

 
 
Já no Portugol Studio funciona de boa:
 

 
Falou

Olá @LucasOne.
 
Você está iniciando o "contador" com 1, mas logo após ler um valor já está mudando para 2... daí a verificação no se não passa.
 

 
Basta colocar para atualizar depois, por exemplo, antes do FimEnquanto.