Simon Viegas

Repositório: https://sourceforge.net/projects/visualg30/files/ Para a 3.0.6.5 (melhor versão), baixar a versão VISUALG3_REV60.rar. Link direto: https://sourceforge.net/projects/visualg30/files/VISUALG3_REV60.rar/download

Um exemplo utilizando funções: algoritmo "Calculadora de idade" funcao RetornarIdade (anoAtual, anoNascimento : inteiro) : inteiro inicio se (anoAtual < anoNascimento) então escreval("Ano atual não pode ser menor que o ano de nascimento!") retorne -1 senao retorne anoAtual-anoNascimento fimSe fimFuncao procedimento VerificarAptoADirigir (anoAtual, anoNascimento : inteiro) var idade : inteiro inicio idade <- RetornarIdade(anoAtual, anoNascimento) escrevaL() se (idade <> -1) então escrevaL("IDADE: ", idade:1," ANOS") se (idade >= 18) então escrevaL("APTO A DIRIGIR") senao escrevaL("NÃO ESTÁ APTO A DIRIGIR") fimSe fimSe fimProcedimento var anoAtual, anoNascimento :inteiro inicio escrevaL("------------------------") escrevaL("DEPARTAMENTO DE TRANSITO") escrevaL("------------------------") escreva ("ANO ATUAL (yyyy): ") leia (anoAtual) escreva ("ANO DE NASCIMENTO (yyyy): ") Leia (anoNascimento) escrevaL("----------STATUS-------") VerificarAptoADirigir(anoAtual, anoNascimento) fimAlgoritmo

@Drelius, a base da lógica estaria certa. Aqui entraria basicamente a sintaxe. Segue: 1. para o c você precisa do resto da divisão, logo o operador seria "\" (em detrimento do "/"); 2. para o d, há uma espécie de bug que não consegue calcular muito bem utilizando o tipo real, daí, mude para inteiro mesmo; Segue código até o momento: algoritmo "Separador de dígitos" var numero : inteiro d, c, u : inteiro Inicio escreva ("Digite um numero menor que 1000: ") leia(numero) se ((numero >= 0) E (numero < 1000)) então c <- numero \ 100 d <- (numero - (c*100)) \ 10 u <- numero - (c*100 + d*10) escreva (c, " centenas,") escreva (d, " dezenas e") escreval(u, " unidades.") senao escreva("Valor invalido") fimSe fimAlgoritmo Pequeno ajuste na formatação: algoritmo "Separador de dígitos" var numero : inteiro d, c, u : inteiro Inicio escreva ("Digite um numero menor que 1000: ") leia(numero) se ((numero >= 0) E (numero < 1000)) então c <- numero \ 100 d <- (numero - (c*100)) \ 10 u <- numero - (c*100 + d*10) escreva (c:1, " centenas, ") escreva (d:1, " dezenas e ") escreval(u:1, " unidades.") senao escreva("Valor invalido") fimSe fimAlgoritmo Resultado: Daí só inserir o restante da lógica. - singular ou plural; - não exibir quando for igual a 0; - ajuste para uso correto de "," ou "e". etc Dica: vá sempre ajustando aos poucos... não tente fazer tudo de uma vez. Adendo: Resolvendo o problema se fosse de fato necessário utilizar real: algoritmo "Separador de dígitos" var numero : inteiro d, c, u : real Inicio escreva ("Digite um numero menor que 1000: ") leia(numero) se ((numero >= 0) E (numero < 1000)) então c <- numero \ 100 d <- Int((numero - (c*100))) \ 10 u <- numero - (c*100 + d*10) escreva (c:1, " centenas, ") escreva (d:1, " dezenas e ") escreval(u:1, " unidades.") senao escreva("Valor invalido") fimSe fimAlgoritmo Adendo 2: mas já adianto! Um mais correto seria utilizar inteiro mesmo, já que cada dígito é apenas inteiro... No aguardo. Adendo 3: "como cheguei a essa conclusão sobre o bug na divisão de reais". Fui testando... a lógica parecia certa. Inseri um valor inteiro (ex.: 23 \ 10) e deu certo, ou seja, o problema era que c era real.. Poderia fazer assim: d <- (numero - (Int(c)*100)) \ 10 Por sinal, ficaria até mais elegante... Daí, se poderia inferir que o operador \ foi projetado para trabalhar apenas com inteiros... (não tenho certeza).

Olá, @Eduardo2022. Basicamente está utilizando a nomenclatura idade tanto para uma variável, tanto para o procedimento. Não pode ser igual, pois estão no mesmo escopo e o VisualG não sabe diferenciar uma da outras. Mude uma delas. Exemplo: algoritmo "Calculadora de idade" procedimento calcularIdade (anoAtual, anoNascimento : inteiro) var idade : inteiro inicio idade <- anoAtual-anoNascimento escrevaL() escrevaL("IDADE: ", idade:1," ANOS") se (idade >= 18) então escrevaL("APTO A DIRIGIR") senao escrevaL("NÃO ESTÁ APTO A DIRIGIR") fimSe fimProcedimento var anoAtual, anoNascimento :inteiro inicio escrevaL("------------------------") escrevaL("DEPARTAMENTO DE TRANSITO") escrevaL("------------------------") escreva ("ANO ATUAL (yyyy): ") leia (anoAtual) escreva ("ANO DE NASCIMENTO (yyyy): ") Leia (anoNascimento) escrevaL("----------STATUS-------") calcularIdade(anoAtual, anoNascimento) fimAlgoritmo Adendo 1: propositalmente eu deixe os mesmo nomes nas variáveis (anoAtual e anoNascmento) globais, e nas variáveis locais, lá do procedimento. Entenda de antemão que são variáveis distintas!!! Nesse caso é permitido utilizar nomenclaturas iguais (são escopos diferentes... 2 são globais, 2 são locais). Já no outro caso, tanto a variável, tanto o procedimento são globais, daí dá conflito, ou seja, como o programa vai saber qual é qual?) Adendo 2: "Ah! Mas para a, por exemplo, variável anoAtual, como o VisualG vai saber qual utilizar já que tem duas com a mesma nomenclatura?". É simples: no escopo global, vai utilizar a variável global, já que as variáveis locais NÃO são enxergadas globalmente (fora do procedimento só existe uma variável mesmo)... e dentro do procedimento vai enxergar o local e global??? Vai utilizar apenas a local mesmo (que está "mais perto"). No VisualG não é possível diferenciar uma da outro (limitação da linguagem - em linguagens mais novas/populares, dá de boa... mas não vem ao caso agora). Adendo 3: só para exemplificar, poderia fazer assim: procedimento calcularIdade (a, b : inteiro) var idade : inteiro inicio idade <- a-b escrevaL() escrevaL("IDADE: ", idade:1," ANOS") se (idade >= 18) então escrevaL("APTO A DIRIGIR") senao escrevaL("NÃO ESTÁ APTO A DIRIGIR") fimSe fimProcedimento Vai funcionar exatamente da mesma forma. Beleza? Tanto utilizar a, quanto utilizar anoAtual, o VisualG vai criar OUTRA variável especificamente para o procedimento... Adendo 4: Ah! evite utilizar variáveis globais diretamente nos procedimentos. O ideal é passar os valores por parâmetro. Como assim? Veja, poderia fazer assim: algoritmo "Calculadora de idade" procedimento calcularIdade() var idade : inteiro inicio idade <- anoAtual-anoNascimento escrevaL() escrevaL("IDADE: ", idade:1," ANOS") se (idade >= 18) então escrevaL("APTO A DIRIGIR") senao escrevaL("NÃO ESTÁ APTO A DIRIGIR") fimSe fimProcedimento var anoAtual, anoNascimento :inteiro inicio escrevaL("------------------------") escrevaL("DEPARTAMENTO DE TRANSITO") escrevaL("------------------------") escreva ("ANO ATUAL (yyyy): ") leia (anoAtual) escreva ("ANO DE NASCIMENTO (yyyy): ") Leia (anoNascimento) escrevaL("----------STATUS-------") calcularIdade() fimAlgoritmo A variável idade poderia ser global também que iria funcionar... esqueci de tirar... deixo aí como exemplo mesmo... Mas observe que o procedimento está utilizando duas variáveis globais... isso não é desejável... Não é proibiiiido, mas tende a trazer problemas e não é uma boa prática!!! Veja também que a variável idade NÃO poderia ser utilizada lá como está no teu código original... ou seja: porque passou os anos por parâmetro e idade usou global? Entende? Precisaria manter a coerência... ou declarar a variável dentro procedimento, assim como fiz acima, ou usar tudo como global mesmo... Qualquer dúvida é só perguntar.

@Elisangela Mendonça, a dica geral é: faça seu programa aos poucos e deixe ele sempre rodando corretamente. Por exemplo, implementa só uma pequena parte: algoritmo "xpto" var resposta: caractere pontos, acertos, erros, soma: inteiro inicio escrevaL("**** Quiz ****") escrevaL() pontos <- 0 acertos <- 0 erros < -0 escrevaL("Na primeira tentativa cada ponto vale 10, na segunda, vale 5") escrevaL() escrevaL("Questão 1:"Para a entrada de dados, utilizamos o parâmetro:") escrevaL("a)leia") escrevaL("b)escreva") escrevaL("Escreva a resposta:") leia(resposta) fimAlgoritmo Aí coloca para rodar: Opa! Deu erro... já tenta corrigir... aí, apenas deixou uma " (aspas duplas a mais... só apagar ali antes do "Para a"). Daí adiciona mais alguma coisa e vai testando... a medida que vai ganhando experiência, vai reduzindo os testes, mas é preciso ter uma boa certeza que "tudo que já fez até aquele momento está rodando sem erros". Nunca deixe para testar no fim... vá implementando e testando logo. Vamos tentar agora implementar a verificação da resposta: ...Tá! Teu código lá não está funcionando... após entender o contexto, para para refazer a lógica e vai fazendo novos testes, exemplo: se (resposta = "a") então escreval("Você acertou!") pontos <- pontos+10 acertos <- acertos+1 senao escrevaL("Resposta errada, tente novamente") escrevaL("Escreva a resposta:") leia(resposta) se (resposta = "a") então escreval("Você acertou!") pontos <- pontos+5 acertos <- acertos+1 senao escreva ("Você errou! 0 pontos nessa rodada") erros <- erros+1 fimse fimSe Agora vamos testar os placares: escrevaL("Placar final ", pontos:1) se (pontos >= 20) então escrevaL("Excelente!") senao se (pontos < 20) então escrevaL("Ótimo!") fimSe fimSe RESUMINDO: Vai testando e ajustando, testando e ajustando, testando e ajustando... o que não pode é "tentar fazer tudo de uma vez e testar tudo de uma vez só". Implementa agora outra pergunta... e vai testando e ajustando... Não se preocupe em tentar fazer o melhor código do mundo... coloque apenas para funcionar... mais pra frente vai implementando melhorias, como no caso do tópico, utilizar vetores (mas não precisa para agora!) Código completo até aqui: algoritmo "xpto" var resposta: caractere pontos, acertos, erros: inteiro inicio pontos <- 0 acertos <- 0 erros <- 0 escrevaL("**** Quiz ****") escrevaL() escrevaL("Na primeira tentativa cada ponto vale 10, na segunda, vale 5") escrevaL() escrevaL("Questão 1: Para a entrada de dados, utilizamos o parâmetro:") escrevaL("a) leia") escrevaL("b) escreva") escrevaL("Escreva a resposta:") leia(resposta) se (resposta = "a") então escreval("Você acertou!") pontos <- pontos+10 acertos <- acertos+1 senao escrevaL("Resposta errada, tente novamente") escrevaL("Escreva a resposta:") leia(resposta) se (resposta = "a") então escreval("Você acertou!") pontos <- pontos+5 acertos <- acertos+1 senao escreva ("Você errou! 0 pontos nessa rodada") erros <- erros+1 fimse fimSe escrevaL("Placar final ", pontos:1) se (pontos >= 20) então escrevaL("Excelente!") senao se (pontos < 20) então escrevaL("Ótimo!") fimSe fimSe fimAlgoritmo

Acho que já corrigiu, né? O problema poderia está ali no "até". É sem acento. ate (Maiusc(resposta) = "N") Adendo 1: não precisa do Maiusc()... mas pode deixar. Fica até mais semântico. Adendo 2: Também não precisa "zerar" as variáveis no VisualG. É feito automaticamente, mas da mesma forma, melhor deixar!!! Adendo 3: tem alguns ajustes finos... só detalhes mesmo. Segue: 1. ali antes do S/N tem um abre chaves em vez do abre colchetes; 2. após o "Foram digitadas" tem um espaço a mais; 3. é possível formatar os números reais, deixando com casas decimais fixas; 4. na último linha também tem um espaço a mais antes do número. Exemplo de correção: escreva ("Quer continuar? [S/N]") leia(resposta) ate (resposta = "N") media <- soma / contador escreval("Foram digitadas ", contador:1, " idades") escreval("Media de idade é ", media:1:2) escreval("Tem ", contador21:1, " pessoas com mais de 21 anos") fimAlgoritmo Resultado:

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.

ADENDO IMPORTNTE Como já comecei a complementar minha respostar anterior antes da tua resposta acima, vou postar do jeito que está... mais abaixo respondo tua nova postagem.. ######### Dando continuidade. Peço desculpa, mas eu costumo ser um pouco prolixo... é o meu jeito. Tento melhorar, mas é complicado. Desculpe-me. Acho que uso isso também para ficar revisando ideias... Faz parte. Dito isso, vamos ao novo exemplo: O código atualmente estaria assim: Vamos para o próximo passo: - retornar -1 caso não encontre nenhuma correspondência e - retornar o número da posição referente ao cadastro da pessoa caso encontre O que até aqui esses "critérios de avalições querem"? Vale ressaltar que seria preciso ler todos os critérios e ir relendo eles até assimilar tudo. Eles fazem parte de uma coisa só e não são necessariamente uma sequência lógica... fui fazendo em ordem apenas para tentar demonstrar o que seria cada item..., ou seja, primeiro entendi mais ou menos o grosso (lé ele - como dizem aqui na Bahia).. aí depois fui seguindo em ordem... Ele quer que "crie uma função de busca por item de registro, onde será usado um nome como referência (para identificar o registro). Daí, quer que retorne a posição desse registro. 'Ah!, mas se não encontrar?'. Retorne o valor -1".. ou seja, lá quem for usar essa função, terá que verificar se o registro é diferente de -1... se for -1, não encontrou. Se for outro valor (que seria entre 1 e o tamanho do vetor), então esse valor seria a posição do registro que eu quero... (registro que eu usei o nome para achar). Isso como ideia... já que pode não funcionar direito... continuando... Talvez poderia ser algo assim: funcao BuscarPeloNome(nomePesquisa : caractere) : inteiro var i : inteiro posicao : logico inicio posicao <- -1 para i de 1 ate posicao_atual faca se (nomePesquisa = usuarios[i].nome) entao posicao <- i fimSe fimPara retorne posicao fimFuncao Lá quando chamar essa função, usaria algo como: posicaoRetornada <- BuscaPeloNome(nomePesquisa) Daí, usaria essa variável para exibir o que quiser. Ex.: escreval("USUARIO [", posicaoPessoa, "]") escreval("Nome: ", usuarios[posicaoPessoa].nome) escreval("Idade: ", usuarios[posicaoPessoa].idade) Tente primeiramente entender as lógicas que sugeri acima... Após, tente entender que eu não consegui "inventar" ela no do nada... pode ter certeza que, em algum momento, sempre haverá um grande esforço... mas, como já tive que em algum momento implementar algo semelhante, provavelmente tentei inventar uma lógica E NÃO DEVO TER CONSEGUIDO... daí pesquisei, é fui me batendo com exemplos parecidos (ou em fóruns ou no Google etc).. e aos poucos fui refinando o que encontrei ou alguém me sugeriu ou vi alguém sugerindo para alguém... O que quero dizer: dificilmente um programador cria algo. Diria que é raro... geralmente vamos tendo contato e experiências... daí vamos readaptando aquilo que já vimos.. Observe que no código acima eu não deixei comentários... isso porque a proposta é que o código seja autoexplicativo. "Códigos não devem precisar de comentários"... Supondo que um código está bem escrito, se não entender de logo de cara, tem que quebrar a cabeça mesmo até similar... daí, tenho certeza, que, ao entender os conceitos, verás que eles podem se repetir em diversos outros momentos, não exatamente iguais, mais pelo menos parecidos... passando assim a tratar como "triviais"..., ou seja, são tipos de coisas que podem parecer complicadas para quem ainda não entendeu, mais automaticamente passando a ser óbvio depois que entender! Segue uma possível explicação do que "imaginei" (copiei / adaptei algum lógica que vi em algum lugar, ou em algum momento, mas que já foi assimilado por mim - ou não): funcao BuscarPeloNome(nomePesquisa : caractere) : inteiro var i : inteiro posicao : logico inicio posicao <- -1 //caso não encontar, ele quer que retorne -1, certo? para i de 1 ate posicao_atual faca se (nomePesquisa = usuarios[i].nome) entao posicao <- i //como essa "alteração do valor" está dentro do "se", só vai atualizar se a condição acima for válida fimSe fimPara retorne posicao //logo, OU vai retornar -1 (valor inicial), OU vai retornar a posição desejada (já que o "se" foi preparado para filtrar isso) fimFuncao Não se preocupe em copiar ideias dos outros..., mas o importante é NÃO copiar e colar os códigos em si, ou seja, entenda a lógica envolvida e redigite tudo na mão...Ao fazer isso, porá inclusive melhorar ou mesmo corrigir... Por exemplo: se você prestou atenção, terá visto que usei um nome de variável errada lá mais acima: Use: escreval("USUARIO [", posicaoPessoa, "]") escreval("Nome: ", usuarios[posicaoPessoa].nome) escreval("Idade: ", usuarios[posicaoPessoa].idade) Mas deveria ser: escreval("USUARIO [", posicaoRetornada, "]") escreval("Nome: ", usuarios[posicaoRetornada].nome) escreval("Idade: ", usuarios[posicaoRetornada].idade) Caso deseje, tente seguir os passos que seguir na postagem anterior e aqui... daí, caso tenha dúvidas em alguma parte, informe qual. Por favor, fique a vontade para tirar qualquer dúvidas, mas tente ir sendo mais específico... RESPOSTA A POSTAGEM ANTERIOR #### Qual erro?

Poste o que já conseguiu fazer 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...

@Eduardo Nitsche, basicamente seguir os passos. Vamos lá... cada uma das etapas estaria basicamente descrevendo as características de um método. Um para buscar, outro para excluir. Você meio que precisaria ler todos os critérios e construir uma base mental de como será o método... ler todo pois cada parte descreve como será. São características de um único método... Vou tentar explicar linha a linha. ETAPA 01 - manter a implementação da S.A. 2 funcional... Não entendi, então vou pular. - implementar um método para realizar a busca de uma pessoa pelo nome Basicamente é isso que essa etapa quer... (Só que vai buscar e faze algo.. que no caso é retornar um valor.) - conter método que possui um valor inteiro como tipo de retorno No VisualG, existe 2 tipos de métodos: função e procedimento. Correto? Como tem retorno, então é uma função. Um esqueleto seria: funcao BuscarPeloNome() : inteiro inicio retorne 0 fimFuncao - conter método que recebe o nome de uma pessoa como parâmetro Autoexplicativo: funcao BuscarPeloNome(nomePesquisa : caractere) : inteiro inicio retorne 0 fimFuncao - verificar em toda a estrutura homogênea a existência de uma correspondência O que seria "estrutura homogênea"? O vetor... funcao BuscarPeloNome(nomePesquisa : caractere) : inteiro var i : inteiro inicio para i de 1 ate posicao_atual faca se (nomePesquisa = usuarios[i].nome) entao fimSe fimPara retorne 0 fimFuncao ... Seria algo bem por aí... Só ir seguindo os próximos passos. Tenta implementar. Qualquer dúvida, pare um pouco para pensar mais... se não conseguir... dê um tempo, vá fazer outra coisa, depois volte... caso ainda fique travado, só postar o que conseguiu fazer e onde está com dúvidas. Adendo: é normal poder ocorrer dificuldade. Inclusive é essa dificuldade que nos faz aprender/assimilar melhor. No aguardo.

Show! Mostrou a cobra e mostrou o pau também. (Lá ele) Só aproveitando o tema... As comparações no VisualG são feitas com apenas um igual (ex.: x = y)... Na maioria das linguagens famosas, utilizam-se dois iguais (ex.: x == y)... um dos motivos disso é que o um "=" seria utilizado para atribuição, e é preciso diferenciar uma coisa da outra lá... Segue: PARA ATRIBUIÇÔES: VisualG: x <- y ou x := y Maioria das outras linguagens: x = y Ou seja, esses são os operadores de atribuição. O valor de y vai ser atribuído na variável x. PARA COMPARAÇÕES VisualG: x = y Maioria das outras linguagens: x == y Ou seja: esses são operadores relacionais. Calcula se o valor x é igual ao valor de y, e que no caso retorna um valor booleano (VERDEIRO ou FALSO para o VisualG, ou true ou false para o "resto do mundo", rs). Em relação à mensagem de erro, parte do "bug" seria devido à limitação do VisualG... que funciona de forma que "interpreta o código apenas em tempo de execução", ou seja, se uma execução do código sequer passar nessa linha, o problema não vai erro relacionado a isso... Aqui o código não é compilado, logo não tem um "compilador que já identifica problemas antes de montar o objeto que vai ser executado".

O VisualG meio que seria "uma Pascal em Português"... Lá no Pascal poderia utilizar o ReadKey(). No VisualG não existe (desconheço) função similar. Exemplo no Pascal: program TesteReadkey; {$CODEPAGE UTF8} //para permitir acentos nas string em alguns compiladores [Não necessário no PascalZim, mas pode deixar] uses CRT; //carrega comandos extras como o ReadKey() [Não necessário no PascalZim, mas pode deixar] var tecla : char; numero : integer; begin tecla := ' '; while (tecla <> #13) do //enquanto diferente de ENTER begin tecla := ReadKey(); if (tecla in ['0'..'9', '+', '-', '*', '/']) then writeln(tecla); end; end. Testando... só exibe o que estiver na faixa: Aí no caso, só converter antes a tecla numéricas para inteiro e fazer o que quiser... Adendo: observe que basicamente o Pascal seria um VisualG em inglês.. só que mais robusto, rs.

Esse -1 pode ser algum código de erro interno (de alguma linguagem de programação do programa VisualG) ou bug mesmo... o curioso que se colocar um número com expoente antes funciona normalmente... vá entender. Se inserir um número real no lado esquerdo também roda, só que de alguma forma deve está "pegando apenas a parte inteira" nesses casos... Tá funcionando mais ou menos assim: r <- Int(<valor_real>) mod <valor_inteiro> Adendo: o Int() basicamente retorna um inteiro que seria parte inteira do real informado. Ex.: 7.8 retorna 7. Só um detalhe: como o "resto da divisão" é também um inteiro, o r poderia ser do tipo inteiro mesmo. Usar real ou inteiro vai do contexto... mas no caso aí, não tem motivo para ser real. (Já que apenas recebe o valor e exibe na tela... como é sempre inteiro, mais coerente utilizar inteiro).

Recomendo utilizar a versão 3.6.0.5. Seria a mais estável... que dá menos problema. Download: https://sourceforge.net/projects/visualg30/files/ (baixe o VISUALG3_REV60.rar) ou Link direto: https://sourceforge.net/projects/visualg30/files/VISUALG3_REV60.rar/download

Constante seria uma "variável de valor fixo". Uma das utilidades para o contexto é que o seu valor é definido logo na criação... e que dá para utilizar como parâmetro para criação dos vetores... No caso aí, caso queira mudar a "quantidade máxima de produtos", bastaria mudar de 10 para o novo valor, por exemplo 25. Sem usar essa constante, teria que sai ajustando várias partes do códigos (trocando de 10 par 25 manualmente). Ela está sendo utilizada na declaração dos vetores: E também na definição do laço de repetição..

Tá, mas o quê que não deu certo? Foi alguma coisa na lógica que você imaginou ou está dando algum erro? Uma dica simples é: vá fazendo aos poucos... deixando funcionado até onde já fez. Vamos lá: o primeiro ponto é que só precisaria de uma variável para resposta; ficou faltando algumas aspas duplas; ficou faltando alguns entao; seria melhor utilizar o "não" sem o "~". Fica mais simples para digitar. (Depois vê isso com mais calma.) Oh! O VisualG não tem compilador (que acusa erros logo ao tentar compilar), daí precisa de uma atenção redobrada ao implementar (pois alguns os erros só ocorrem quando na execução bate lá)... Segue uma base: algoritmo "Jogo de Adivinhação" var resposta : caractere inicio escreval("Jogo de Adivinhação") escreval("Dentro os meios de transporte pense em um: ") escreval("- Trator") escreval("- Moto") escreval("- Bicicleta") escreval("- Trem") escreval("- Carro") escreval("- Caminhão") escreval("- Ônibus") escreval("- Paraquedas") escreval("- Balão") escreval("- Avião") escreval("- Helicóptero") escreval("- Submarino") escreval("- Barco") escreval("- Navio") escreval("- Lancha") escreval("") escreval("É terrestre?") leia(resposta) se resposta = "sim" entao escreval("É pesado?") leia(resposta) se resposta = "sim" entao escreval("É um trator") senao se resposta = "não" entao escreval("Usa capacete?") leia(resposta) se resposta = "sim"entao escreval("O transporte é uma moto") senao se resposta = "não" entao escreval("Usa trilho?") leia(resposta) se resposta = "sim" entao escreval("O tranporte é um trem") senao se resposta = "não" entao escreval("É um veiculo leve?") leia(resposta) se resposta = "sim" entao escreval("O transporte é um carro") senao se resposta = "não" entao escreval("Usa carroceria?") leia(resposta) se resposta = "sim" entao escreval("O transporte é uma carroça") senao se resposta = "não" entao escreval("O tranporte é um ônibus") se resposta = "não" entao escreval("É aérea?") leia(resposta) se resposta = "sim" entao escreval("Precisa Pular?") leia(resposta) se resposta = "sim" entao escreval("O transporte é uma Asa Delta") senao se resposta ="não" entao escreval("É devagar?") leia(resposta) se resposta = "sim" entao escreval("O transporte é um Balão") senao se resposta = "não" entao escreval("Possui asas fixas?:") leia(resposta) se resposta = "sim" entao escreval("O tranporte é um Avião") senao se resposta = "não" entao escreval("O transporte é um Helicóptero") senao se resposta = "não" entao escreval("O transporte é áquático?") leia(resposta) se resposta = "sim" entao escreval("É coberto d'água?") leia(resposta) se resposta = "sim" entao escreval("O transporte é um Submarino") senao se resposta = "não" entao escreval("Possui Vela?") leia(resposta) se resposta = "sim" entao escreval("O transporte é um barco") senao se resposta = "não" entao escreval("É alto?") leia(resposta) se resposta = "sim" entao escreval("O transporte é um Navio") senao se resposta ="não" entao escreval("O transporte é uma lancha") senao se resposta = "não" entao escreval("O transporte é inválido") fimse fimse fimse fimse fimse fimse fimse fimse fimse fimse fimse fimse fimse fimse fimse fimse fimse fimse fimse fimse fimse fimse fimse fimse fimse fimse fimse fimse fimalgoritmo Não sei se tá 100% corrigido... mas seria algo por aí. Observe que não mexi nada em relação à lógica... apenas em relação a sintaxe e alguns pequenos detalhes. No VisualG o que precisa é isso mesmo: implementar com o máximo de atenção. Agora... em relação à lógica do problema... creio que funciona com cadeias de se/senao... basicamente você precisaria reajustá-las... Veja, por exemplo, no início você pergunta se é terrestre... daí, a depender das respostas, estaria perguntando se é aérea... não faz sentido, percebe? (Oras! Eu já disse "sim' para terrestre., Não tem como ser aéreo.) Indo direto ao ponto: agrupe características mutuamente exclusivas, ou seja, que "se for um, não pode ser outro". A dica geral é ir do mais genérico para o mais específico. Exemplo prático: algoritmo "Jogo de Adivinhação" var resposta : caractere inicio escreval("Jogo de Adivinhação") escreval("Dentro os meios de transporte pense em um: ") escreval("- Trator") escreval("- Moto") escreval("- Bicicleta") escreval("- Trem") escreval("- Carro") escreval("- Caminhão") escreval("- Ônibus") escreval("- Paraquedas") escreval("- Balão") escreval("- Avião") escreval("- Helicóptero") escreval("- Submarino") escreval("- Barco") escreval("- Navio") escreval("- Lancha") escreval("") escreval("É terrestre?") leia(resposta) se (resposta = "sim") entao //aqui tudo que é terreste escreval("Entrou no TERRESTRE") senao escreval("É aéreo?") leia(resposta) se (resposta = "sim") entao //aqui tudo que é aéreo escreval("Entrou no AÉREO") senao escreval("É aquático?") leia(resposta) se (resposta = "sim") entao //aqui tudo que é aquático escreval("Entrou no AQUÁTICO") fimSe fimSe fimSE fimalgoritmo Já dá para ver que a complexidade é alta... entretanto dá para funcionar... Iniciando os terrestres: algoritmo "Jogo de Adivinhação" var resposta : caractere inicio escreval("Jogo de Adivinhação") escreval("Dentro os meios de transporte pense em um: ") escreval("- Trator") escreval("- Moto") escreval("- Bicicleta") escreval("- Trem") escreval("- Carro") escreval("- Caminhão") escreval("- Ônibus") escreval("- Paraquedas") escreval("- Balão") escreval("- Avião") escreval("- Helicóptero") escreval("- Submarino") escreval("- Barco") escreval("- Navio") escreval("- Lancha") escreval("") escreval("É terrestre?") leia(resposta) se (resposta = "sim") entao escreval("É pesado?") leia(resposta) se (resposta = "sim") entao escreval("É um trator") senao escreval("Usa capacete?") leia(resposta) se (resposta = "sim") entao escreval("O transporte é uma moto") fimSe fimSe senao escreval("É aéreo?") leia(resposta) se (resposta = "sim") entao //aqui tudo que é aéreo escreval("Entrou no AÉREO") senao escreval("É aquático?") leia(resposta) se (resposta = "sim") entao //aqui tudo que é aquático escreval("Entrou no AQUÁTICO") fimSe fimSe fimSE fimalgoritmo Por aí vai... Veja que NÃO IMPORTA onde vou "começar a crescer o código". Se quiser, já dá para jogar uns aquáticos... tanto faz... isso ocorre porque os se (estruturas de seleção) servem justamente para isso: "selecionar um caminho". Também conhecido como "desvio condicional"..., ou seja, que "desvia o fluxo natural do programa"... DICA FUNDAMENTAL: sempre mantenha seu código indentado. No VisualG é só pressionar Ctrl+G. Vá se acostumando com os alinhamentos dos dentes... Digitou um trecho de código novo? Ctrl+G na veia... observe que se faltar, por exemplo, um fimSe, muda todo o alinhamento (indicando que tem algo errado).. daí vai lá e vê onde tá faltando... mas o ideal é após inserir um se, já procurar ver e inserir já o respectivo fimSe. O código vai ficar um balaio de gato, mas dá para dar certo. Tentando por esse caminho que mostrei ou por outro, qualquer dúvida e comentários é só postar.

Aí você está verificando se o nome do mecânico é igual a 0? O nome é um número?

@Marlon Gramacho e @devair1010, escolha não funciona para números reais. Nesse caso, poderiamse utilizar uma cadeia de se/senao. Outro ponto que números decimais no texto do código ficam com "." em vez de "," (ex.: 0.85). Já para digitar tanto faz (ex.: 0.85 ou 0,85) Exemplo de código: algoritmo "Nível de Emissão de Gastas Poluentes" var nivelPoluicao : real op : caractere inicio repita escrevaL("____________________________________________________________") escrevaL(" Secretaria Municipal de Meio Ambiente ") escrevaL(" SMMA ") escrevaL("____________________________________________________________") escrevaL(" Software Controlador de Emissão de Gases Poluentes") escrevaL(" CEGP - Vitória da Conquista ") escrevaL(" ") escreva ("Informe o nível de poluição: ") leia(nivelPoluicao) se (nivelPoluicao <= 0.69) entao escrevaL("Todas as empresas podem funcionar normalmente") senao se (nivelPoluicao <= 0.7) entao escrevaL("1º grupo de empresas com suas atividades suspensas") senao se (nivelPoluicao <= 0.8) entao escrevaL("1º e 2º grupo de empresas com suas atividades suspensas") senao se (nivelPoluicao <= 0.9) entao escrevaL("1º, 2º e 3º grupo de empresas com suas atividades suspensas") senao escrevaL("Nível inválido") fimSe fimSe fimSe fimSe escreva ("Voltar para o menu (S/N)?") leia(op) ate op = "n" fimAlgoritmo Adendo: para saber os parâmetros corretos, precisaria do enunciado completo da questão.

Então, "escolha/caso" é uma estrutura de seleção, ou seja, seria uma opção contra "se/então". Só para exemplificar. Isso: É análogo a isso: escolha resposta caso "A" escrevaL("Vamos cadastrar os alunos da turma A") caso "B" escrevaL("Vamos cadastrar os alunos da turma B") caso "C" escrevaL("Vamos cadastrar os alunos da turma C") caso "D" escrevaL("Vamos cadastrar os alunos da turma D") fimEscolha São "a mesma coisa"... apenas escritos de formas diferentes. Sobre: Faça por etapas. Exemplo: Antes, uma dica/orientação importante: Use OU camelCase, OU snake_case para as nomenclaturas de variáveis.. No caso no snake, começando com minúscula... Iniciando com Maiúscula fica muito confuso para ler... Segue um exemplo de esboço inicial: Código: algoritmo "Aprovados num vestibular" //Após uma prova de vestibular, uma escola quer identificar [1] quantos dos //seus alunos foram aprovados em cada turma de formandos. Ela quer saber [2] //qual aluno teve a maior nota e de [3] qual turma ele é. Nessa escola, há //quatro turmas (A, B, C e D) com vinte e cinco alunos cada. //Elabore um algoritmo que solicite o nome e a nota do vestibular aos alunos. //Depois, informe quantos deles foram aprovados, de que turma são, qual a maior //nota em cada turma e qual aluno teve a maior nota de todas. //Para que o aluno seja aprovado no vestibular, ele deverá obter nota maior ou //igual a 7. //ATENÇÃO: As notas por turma não podem se repetir. var nome : caractere nota : real contAluno, contTurma : inteiro qtdAprovTurmaA, qtdAprovTurmaB : inteiro qtdAprovTurmaC, qtdAprovTurmaD : inteiro letraTurma : caractere inicio escrevaL("-------------------------------------------") escrevaL("------------- Escola Progresso ------------") escrevaL("-------------------------------------------") escrevaL("") escrevaL("---- Sistema de notas - Vestibular --------") escrevaL("") escrevaL("") para contTurma de 1 ate 4 faca escolha contTurma caso 1 letraTurma <- "A" caso 2 letraTurma <- "B" caso 3 letraTurma <- "C" caso 4 letraTurma <- "D" fimEscolha escrevaL("") escrevaL("######################") escrevaL("TURMA: ", letraTurma) para contAluno de 1 ate 3 faca escrevaL("") escrevaL("Aluno ", contAluno:1) escrevaL("Dados do aluno") escreva ("Nome: ") ALEATORIO ON lista "Estados" leia(nome) escreva ("Nota: " ) ALEATORIO 3,10 leia(nota) ALEATORIO OFF se (nota >= 7) entao escrevaL("Aluno foi aprovado") escolha letraTurma caso "A" qtdAprovTurmaA <- qtdAprovTurmaA+1 caso "B" qtdAprovTurmaB <- qtdAprovTurmaB+1 caso "C" qtdAprovTurmaC <- qtdAprovTurmaC+1 caso "D" qtdAprovTurmaD <- qtdAprovTurmaD+1 fimEscolha senao escrevaL("Deu zebra") fimSe fimPara fimPara fimAlgoritmo Vê o que dá para melhorar ou ajustar... aí insere mais alguma coisa, como: Como verifica a maior nota? Você já sabe. Como sabe qual a turma do aluno? Só pegar o valor da letraTurma.

@NinjaDoBairro, segue um esboço inicial: algoritmo "Maior e Menor alturas" //Criar um código que receba altura e sexo de 10 pessoas, e depois imprimir na //tela a menor altura feminina e a menor altura masculina. var altura : real sexo : caractere maiorAlturaFeminina : real menorAlturaMasculina : real inicio escreval("Altura : ") leia(altura) escrevaL("Sexo : ") leia(sexo) fimAlgoritmo Daí, vá entendendo o problema e vá ajustando o código aos poucos. Por exemplo, tente pegar primeiro apenas o maior. Caso já tenha feito algo, poste o teu código completo e onde está com dúvidas... Caso queira se basear pelo código acima, vá fazendo os ajustes... mas tente fazer algo. No aguardo.

Sobre: Até onde sei, essa estrutura não pode ser implementada para VisualG. Basicamente um algoritmo só pode ter um fimAlgoritmo, que é aquele que fica no final do programa. (Assim como não existe "end." no meio de um código em Pascal). Uma forma de fazer seria com uma estrutura de seleção. Algo assim: var cartelas: vetor[1..QTD_CARTELAS, 1..6] de inteiro i, j, c : inteiro numeroSorteado : inteiro unico : logico opcao : caractere inicio escreval("Seja bem vindo a loteria do João") escreval("") escreval("Você deseja comprar?") escreval("[1] - Sim") escreval("[2] - Não") leia(opcao) se (opcao = "1") entao para i de 1 ate QTD_CARTELAS faca para j de 1 ate 6 faca unico <- FALSO //etc fimSe Ou seja, aquilo que vai ser executando quando sim dentro da estrutura da estrutura de seleção. Tá, mas veja: É preciso antes definir o que precisa ser feito. Por exemplo, se no enunciado tivesse algo como "perguntar quantos jogos o cliente deseja fazer e gerar no máximo até 20 jogos". Poderia ser algo como: algoritmo "Exercício 7" const QTD_CARTELAS_MAX = 20 var cartelas: vetor[1..QTD_CARTELAS_MAX, 1..6] de inteiro i, j, c : inteiro numeroSorteado : inteiro unico : logico qtdJogos : inteiro inicio escreval("Seja bem vindo a loteria do João") escreval("") repita escrevaL("'Informe um valor entre 1 e ", QTD_CARTELAS_MAX:1, "'") escreval("Quantas jogos deseja fazer?") leia(qtdJogos) escrevaL("") ate ((qtdJogos >= 1) E (qtdJogos <= QTD_CARTELAS_MAX)) para i de 1 ate qtdJogos faca para j de 1 ate 6 faca unico <- FALSO enquanto (não unico) faca numeroSorteado <- RandI(60)+1 unico <- VERDADEIRO para c de 1 ate 6 faca se cartelas[i,c] = numeroSorteado entao unico <- FALSO fimSe fimPara fimEnquanto cartelas[i,j] <- numeroSorteado fimPara fimPara para i de 1 ate qtdJogos faca para j de 1 ate 6 faca escreva (cartelas[i,j]:3) fimPara escreval("") fimPara fimAlgoritmo Em fim, tudo vai depender daquilo que foi pedido... Por favor, poste o enunciado completo da questão. Qualquer dúvida é só perguntar também.

@Giovanna Gabrielle, algumas pontos inicias: Sobre "Maior nota" e "Aluno aprovado", são duas verificações distintas: se (nota > melhor_nota) entao melhor_nota <- nota na <- a fimSe se (nota >= 7) entao escreval("Aluno foi aprovado") qtd_aprovados <- qtd_aprovados + 1 senao escreval("Aluno foi reprovado") fimSe Para ser aprovado não precisa ser a atual maior nota. Sobre Sim. Acho que poderia ser com "escolhacaso". Sobre Poderia criar uma variável para cada turma. Só usar a mesma variável para todos. Basicamente você precisaria verificar qual a maior nota das maiores notas.

@luquinhas44, poste o enunciado completo da questão.

A proposta para resolver qualquer problema é primeiro tentar entendê-lo. Basicamente ele quer coletar alguns dados relacionados a notas e quer uma espécie de relatório... Partindo para implementação, cria um esboço inicial: algoritmo "Aprovados num vestibular" //Após uma prova de vestibular, uma escola quer identificar [1] quantos dos //seus alunos foram aprovados em cada turma de formandos. Ela quer saber [2] //qual aluno teve a maior nota e de [3] qual turma ele é. Nessa escola, há //quatro turmas (A, B, C e D) com vinte e cinco alunos cada. //Elabore um algoritmo que solicite o nome e a nota do vestibular aos alunos. //Depois, informe quantos deles foram aprovados, de que turma são, qual a maior //nota em cada turma e qual aluno teve a maior nota de todas. //Para que o aluno seja aprovado no vestibular, ele deverá obter nota maior ou //igual a 7. //ATENÇÃO: As notas por turma não podem se repetir. var inicio fimAlgoritmo Observe que é pura interpretação de texto... Uma dica interessante é abstrair o problema geral em problemas menores.. Por exemplo, de vez de tentar fazer tudo de uma vez, que tal fazer algo mais simples, como por exemplo encontrar a maior nota de apenas uma turma? Algo como: algoritmo "Aprovados num vestibular" //Após uma prova de vestibular, uma escola quer identificar [1] quantos dos //seus alunos foram aprovados em cada turma de formandos. Ela quer saber [2] //qual aluno teve a maior nota e de [3] qual turma ele é. Nessa escola, há //quatro turmas (A, B, C e D) com vinte e cinco alunos cada. //Elabore um algoritmo que solicite o nome e a nota do vestibular aos alunos. //Depois, informe quantos deles foram aprovados, de que turma são, qual a maior //nota em cada turma e qual aluno teve a maior nota de todas. //Para que o aluno seja aprovado no vestibular, ele deverá obter nota maior ou //igual a 7. //ATENÇÃO: As notas por turma não podem se repetir. var nota : real maiorNota : real i : inteiro inicio maiorNota <- 0 para i de 1 ate 5 faca escreva ("Nota: ") leia(nota) se (nota > maiorNota) entao maiorNota <- nota fimSe fimPara escrevaL("Maior nota: ", maiorNota:1:2) fimAlgoritmo Para facilitar a tua vida, coloque para gerar números aleatórios (é uma perda de tempo absurda ficar digitando a cada testes). Algo como: para i de 1 ate 5 faca escreva ("Nota: ") ALEATORIO 3,10 leia(nota) ALEATORIO OFF se (nota > maiorNota) entao maiorNota <- nota fimSe fimPara Simplesmente o VisualG vai "digitar" números aleatórios para os leia que estiverem entre os comando ALEATORIO... bem autoexplicativo. Daí dá até para ir testando com 25 mesmo, só mudar o parâmetro do laço de repetição. Pronto... agora implemente outra coisa, por exemplo, coloque para ler nomes (nome) e use outra variável para armazenar o nome da aluno com a maior nota (nomeMaiorNota). Exibia também o nome junto com a maior nota. Poste o código aqui. Se tiver dúvidas, é só postar. Se terminar, tente implementar outra coisa, exemplo: contar quantos foram aprovados. Crie uma variável para servir de contador (qtdAprovados) e uma estrutura de seleção (se) para verificar se foi aprovado ou não (ir atualizando a variável). Exiba também a quantidade de aprovador na tela... por aí vai.