Simon Viegas

@Nikollas G. Ohta, num mesmo laço de repetição, já verifica o maior e o maior... O cerne aqui está na "inicialização das variáveis maior e menor". Tem 2 formas: - ou inicializar com o primeiro valor; - ou inicializa o menor com um maior valor possível e o maior com um menor valor possível. Segue um exemplo utilizando o primeiro modo: program Maior_Menor_Vet; {$CODEPAGE UTF8} //para permitir acentos nas string em alguns compiladores uses CRT; var vet: array [1..20] of integer; i, maior, menor, localMai, localMen: integer; begin Randomize; //usado para "embaralhar" a geração de números aletatórios (evitar repetições ao reexecutar o programa) //preenche o vetor com os números for i:=1 to 20 do begin write('Digite um valor para o ', i:2 ,'º vetor: '); //readln(vet[i]); //caso queira digitar manualmente, descomente essa linha e comente a linha de baixo vet[i] := Random(100); writeln(vet[i]); //recuso para preencher automaticamente o vetor end; //inicializa o maior e o menor com o primeiro valor maior := vet[i]; menor := vet[i]; //para cada número (a partir do segundo, já que o primeiro já está atribuído) for i:=2 to 20 do begin //se o valor atual maior que o maior if (vet[i] > maior) then begin maior := vet[i]; //pega o valor do maior localMai := i; //pega a posição do maior end; //se o valor atual menor que o menor if (vet[i] < menor) then begin menor := vet[i]; //pega o valor do menor localMen := i; //pega a posição do menor end; end; writeln; writeln('O menor valor é: ', menor:2, '. Está localizado na posição ', localMen:2, ' do vetor.'); writeln('O maior valor é: ', maior:2, '. Está localizado na posição ', localMai:2, ' do vetor.'); ReadKey(); end. Observação: esses comentários não são necessário (tirando o primeiro lá no topo, que é algo bem atípico)... pois a ideia é que o próprio código seja autoexplicativo, não necessitando de "explicações" (se está tentando explicar, é porque fez de modo meio confuso )... inserir eles para tentar enfatizar, mas não deveria ser necessário. Adendo: ali no preenchimento do vetor, eu deixei os 2 comandos na mesma linha para ficar visualmente mais elegante, mas poderia ser um em baixo do outro... ali está "sorteando um número de 0 a 99", "atribuindo ao vetor na posição i", e "escrevendo o conteúdo do vetor na mesma posição" (para aparecer na tela o que foi gerado). Dessa forma "simulando" uma digitação do usuário... já que seria chaaaato ficar digitando um monte de números a cada teste do programa Segue teste no compilador Free Pascal: Teste no PascalZim:

Sobre: Crie outro vetor, por exemplo: excluidos :vetor [1..4] de logico Quando cadastrar: excluidos[posicaoItem] <- FALSO Obs.: no VisualG já ficará automaticamente com FALSO, mas atribua manualmente o valor! Quando excluir: excluidos[posicaoItem] <- VERDADEIRO Obs. 2: lembrando que FALSO e VERDADEIRO são valores... ficam sem aspas mesmo. Ah! vale salientar que na exclusão NÃO se apagar os dados.. apenas "marca como excluído". Normalmente também o registro fica lá... ou seja: uma vez usado, um mesmo código não pode ser reutilizado por outro produto. Precisará ajustar o restante do código para verificar esse dado..., por exemplo: só vai imprimir os que "não estão excluídos"... Aí verifique quais partes... Mais abaixo tem um exemplo... Sobre: Se o valor está sendo atualizado, não faz sentido em falar em "constante". Isso é uma variável. E acho que faria mais sentido algo assim: Se quiser deixar o código ainda mais semântico, poderia fazer algo assim: totalProdutos <- totalProdutos+1 //atualiza o total de produtos cadastrados codItem <- totalProdutos //código do próximo cadastro Outra coisa... separe a "consulta de estoque" da "venda de produtos". Na hora de vender, não precisaria listar... o cara vai lá e informa o produto que quer... (Ou ele já sabe qual é, ou ele foi antes no menu e consultou.) Para imprimir todos os produtos ou editar, está precisando imprimir um produto... perceba que são praticamente a mesma coisa, ou seja: está repetitivo... poderia criar um procedimento para listar um produto.. daí chama essa função em ambos métodos (listar e editar... e onde quiser mais). Exemplo: procedimento imprimir_produto(cod: inteiro) inicio se ((cod >= 1) E (cod <= totalProdutos)) entao //verifica se é um código válido se (não excluidos[cod]) entao //verifica se está excluído escreval() escreval("Código : ", cod:1) escreval("Descrição : ", descricoes[cod]) escreval("Quantidade : ", quantidades[cod]:1) escreval("valor de venda: R$", precosVendas[cod]:1:2) escreval("------------------------------------------") escreval() senao escreval("Item ", cod:1, " está excluído") fimSe senao escreval("Código ", cod:1, " é inválido") fimSe fimProcedimento Vê se as ideias vão fazendo sentido e vai adaptando ao seu código. Sobre: Aí você precisa pensar numa forma de ter um valor como base... quando o programa encerrar, verificaria qual a porcentagem da quantidade atual dos produtos em relação a esse quantidade base... Ah! a depender crie um outro vetor para armazenar a quantidade padrão...

Complementando: Acrescentar 70% seria equivalente a "o valor atual + 70% desse valor atual". Traduzindo: 1700 + 1700*(70%) = //"valor atual + 70% do valor atual" 1700 + 1700 * (70/100) = //representação da porcentagem em forma de fração 1700 * (1 + 70/100) //colocando o 1700 em evidência Ou seja: tanto faz você fazer: valorAcrescidoDe70Porcento = valorOriginal + valorOriginal*(70/100) Com uma variável para a porcentagem: valorAcrescidoDe70Porcento = valorOriginal + valorOriginal*(porcentagem) Tanto fazer: valorAcrescidoDe70Porcento = valorOriginal * (1 + 70/100) ou valorAcrescidoDe70Porcento = valorOriginal * (1 + porcentagem) Essa segunda forma seria uma "simplificação"... uma fórmula que só precisa acessar a variável uma vez... pense assim: na matemática, "nada se cria, nada se perde, tudo se transforma". As "fórmulas" são (devem ser) sempre "100% equivalentes entre si". Adendo: Observe a expressão: 1700 * (1 + 70/100) Fazendo a distributiva ficaria: 1700 + 1700 * (70/100) Ou seja: "colocar um termo em evidência seria o oposto da distributiva.

Bastaria fazer algo como: quantidades[icod] <- quantidades[icod] - vendaqtt Sobre o programa em si... Uma proposta que poderia ser interessante seria você separar a parte do "domínio" com a parte da "interface"... Como assim? Então, por exemplo, para cadastrar, você teria uma função responsável em "coletar os dados do produto" (interface) e outra função para "cadastrar esses dados no vetor" (domínio). Fiz um esboço.. vê se consegue aproveitar alguma coisa: algoritmo "Controle de Estoque" // Disciplina : // Professor : // Descrição : // Autor(a) : Renan Vinycius) // Data atual : 29/07/2021 //REQUISITOS: // 1 Funcionalidades do sistema // 1.1 Cadastrar produto // 1.2 Alterar produto // 1.3 Excluir produto // 1.4 Consultar produto // 1.5 Vender produto // 1.6 Consultar estoque // 2 Atributos de um produto // 2.1 Descrição // 2.2 Mome // 2.3 Quantidade // 2.4 Código. // 3 Criar critério após encerrar programa apresentar se algum produto precisa // ser comprado para repor estoque, considerar estoque baixo, 30% da quantidade // cadastrada. // 4 Elaborar os menus recursivos na qual você pode avançar e voltar nos menu. //Responsável em cadastar um produto no vetor //Parâmetros //1-Produto a ser cadastrado procedimento CadastrarProduto() inicio totalProdutos <- totalProdutos+1 //atualiza o total de produtos cadastrados produtos[totalProdutos] <- produtoAux //cadastra na posição correspondente //ADENDO: esse "produtoAux" seria um parâmetro do procedimento, mas o //VisualG não suporta (não foi implementado ainda). Daí, para contornar, //declarei como uma variável global e acesso diretamente (simulando o parâmetro). //ADENDO 2: tanto o vetor, tatno a total de itens cadastrados também deveriam //vir por parâmetro, mas fica mais prático acessá-los diretamente pelas variáveis //globais. (obs.: não é possível passar um vetor por parâmetro no VisualG) fimProcedimento //Responsável em alterar um produto no vetor //Parâmetros: //1-Produto alterado //2-Posição do produto procedimento AlterarProduto(p: inteiro) inicio produtos[p] <- produtoAux fimProcedimento //Responsável em excluir um produto no vetor //Parâmetro: //1-Posição do produto a ser excluído procedimento ExluirProduto(p: inteiro) inicio fimProcedimento //Responsável em exibir os dados de um produto //Parâmetro: //1-Posição do produto procedimento ExibirProduto(p: inteiro) inicio escreva (produtos[p].nome:20) escreva ("":3, produtos[p].codigo:3) escreva ("":3, produtos[p].descricao:20) escreva ("":3, produtos[p].quantidade:3) escreval() fimProcedimento //Responsável em coletar os dados de um produto novo e "solicitar" cadastro no vetor //Parâmetro: NENHUM procedimento TelaCadastrarProduto() var novoProduto: t_Produto sucesso: logico inicio //aqui fluxo para para solicitar e ler os dados do produto //vou criar um produto aleatório, diretamente, apenas para teste novoProduto.codigo <- Randi(100) novoProduto.nome <- "Produto " + NumPCarac(Randi(100000)) novoProduto.descricao <- "Descrição teste" novoProduto.quantidade <- 50+Randi(50) //aqui vai cadastrar o produto no esoquete //o produto deveria ser passado por parâmetro, mas como não funciona no // VisualG, //daí, copia numa variável auxiliar e utiliza a variável lá no procedimento produtoAux <- novoProduto CadastrarProduto() fimProcedimento procedimento BuscarProdutoPorCodigo() inicio fimProcedimento //Responsável em verificar qual produto vai ser alterar, coletar os novos dados //e solicitar o cadastro da alteração no vetor //Parâmetro: NENHUM procedimento TelaAlterarProduto() var produtoAlterado: t_produto posProdutoAlterar: inteiro inicio //quero alterar o produto 2 posProdutoAlterar <- 2 //copio o produto que quero alterar produtoAlterado <- produtos[posProdutoAlterar] //altero o que quero alterar (no exemplo, removendo 10 da quantidade) produtoAlterado.quantidade <- produtoAlterado.quantidade-10 produtoAux <- produtoAlterado AlterarProduto(2) fimProcedimento tipo t_Produto = registro codigo: inteiro nome: caractere descricao: caractere quantidade: inteiro fimRegistro var produtos: vetor [1..10] de t_Produto totalProdutos: inteiro //total de produtos cadastrados produtoAux: t_Produto //variável utilizanda para pasasr um produto para as funções inicio totalProdutos <- 0 //inicializar com 0 produtos cadastrados TelaCadastrarProduto() ExibirProduto(1) TelaCadastrarProduto() ExibirProduto(2) TelaCadastrarProduto() ExibirProduto(3) escreval() escreval() TelaAlterarProduto() ExibirProduto(2) fimAlgoritmo

@dve, poste o enunciado original completo.

@Renan Vinycius, poste o que já fez e qual parte está com dúvidas. Sobre: Crie um procedimento... que recebe o código do produto que está sendo atualizado e a quantidade de itens que foram vendidos. Não implemente a parte da venda... isso é de outro escopo... Você simplesmente precisa saber qual produto está sendo vendido (código do produto) e quantos foram vendidos (a quantidade), daí atualiza o estoque. De início NÃO se preocupe com Regra de Negócios, ou seja: sempre suponha que todos os dados serão digitados corretamente; que não vai "vender uma quantidade que existe no estoque"; que não vai informar um código de produto inválido etc. Deixa isso para depois... O mais importante é a base.

@Ferreira_Theu, só uma refatorada: melhor inicializar o contador com 0, afinal não tem número algum cadastrado; o VisualG insere espaços antes do número (loucura dele), daí formatando com :x resolve isso; (x = números de casas reservadas.) como são condições mutuamente excludentes entre si, faz mais sentido lógico utilizar o se/senao; (Pelo menos nessa fase de aprendizagem.); o comando ALEATORIO serve apenas para preencher automaticamente. Segue: algoritmo "Maior e menor valores" var cont: inteiro valor, maior, menor: real inicio cont <- 0 ALEATORIO 1, 80 enquanto (cont <= 8) faca cont <- cont + 1 escreva("Digite o valor do ", cont:1, "º produto: ") leia(valor) se cont = 1 entao menor <- valor maior <- valor senao se valor > maior entao maior <- valor senao se valor < menor entao menor <- valor fimSe fimSe fimSe fimEnquanto ALEATORIO OFF escreval() escreval("O produto mais caro teve o valor de R$ ", maior:1:2) escreval("O produto mais barato teve o valor de R$ ", menor:1:2) fimAlgoritmo Adendo: outra forma de preencher automaticamente seria utilizar a própria "IDE": Dessa forma não precisando do ALEATORIO no código... aí habilitando ou desativando lá por esse menu. Exemplo de resultado: Ah! Usando no código tem a característica de poder definir a faixa de valores... teste os 2 para entender um pouco melhor.

Exatamente... por isso que seria bom logo inicializar os dois (o maior e o menor) com o primeiro valor... acho também que seria melhor forma.

@Tiagodeoliveira, por favor, poste o texto do código código. Adendo: favor usar o botão CODE (ícone <> na barra de ferramentas).

@Ferreira_Theu, a sua "gambiarra" não seria uma gambiarra... seria uma solução em si. Sobre: Basicamente você teria 2 formas: inicializar o menor com um maior valor possível; (O que você fez.) inicializar o maior e o menor com o primeiro valor.

Ok. Movi o tópico para C++. E sobre?

@JVT_M, em qual linguagem de programação precisa resolver esse problema? Por favor, poste o que já conseguiu fazer e em qual parte está com dúvidas.

@Rafahewl, sobre: As variáveis a, b, c e d foram declaradas, mas não foram utilizadas. Basta apagar as declarações, exemplo: var problema: caractere x, y: inteiro Adendo: se foi algo relacionado as opções lá no menu... perceba que lá são verificadas o "texto" da resposta... e isso não é uma variável... Tipo: se (problema = "c") entao escreval("A multiplicação dos numeros digitados é:", x*y) Traduziria em algo como se o conteúdo da variável programa tiver o caractere "c", então faça o que está na linha abaixo". Adendo: lembrando que a divisão por 0 (zero) não se dá muito bem com computadores, né? Daí, seria bom colocar uma verificação para não permitir tentar calcular a divisão caso y seja igual a 0.

@VedZinn, só alguns pontos: Apesar do código ficar bom, esse tópico seria para Portugol Studio, mas o seu código está para VisualG... eles possuem sintaxe distintas... mas tá valendo. Em relação ao código... é recomendável manter o código semântico... no caso, na fórmula de Bhaskara não existe o conceito de "Delta 2" e "Delta 3"... Só tem um Delta e pronto. Outro ponto é que o que estaria se procurando era o valor de "Delta", e não de "Delta 3"... se fosse o caso, a resposta final ficaria na variável Delta. Segue o trecho: Basta efetuar a conta diretamente: delta <- Exp(nB, 2) - 4*nA*nC escrevaL("Delta: ", delta:1:3) Sobre: Essa variável não faz sentido e não está sendo utilizada... basta apagar do código.

Para mim esse enunciado não faz o menor sentido... já começa com o com uso incorreto do "o mesmo"... Mas falando sério, por favor, poste o enunciado completo da questão e em qual parte estaria com dúvidas... Outra coisa: qual "IDE" está utilizando para editar e rodar o código? Seria o Portugol Studio, VisualG, PortugolIDE.. qual?

A postagem é de 2008, mas caso alguém se esbarre: Sobre: Funções e Procedimentos são praticamente a mesma coisa!!! Um procedimento nada mais é que uma função que não tem retorno nela mesma!!! Só muda isso. No resto é exatamente igual. Isso de chamar de "função" (function) ou "procedimento" (procedure) seria apenas* no Pascal/Delphi... e o VisualG herdou essa característica (já que é baseado neles... só que traduzido para Português). É mais normal chamar tudo de função mesmo... O VisualG utiliza mais ou menos essa estrutura: Quando precisasse retornar algo, definiria um tipo ali no final da assinatura: funcao NomeDaMinhaFuncao(parametro :tipo): tipo inicio retorne xxx //xxx seria algum valor do tipo que está definido ali na assinatura fimFuncao Quando não precisasse retornar algo, muda para procedimento: procedimento NomeDoMeuProcedimento(parametro :tipo) inicio fimProcedimento Mas tipo... qualquer* outra linguagem meio que continua utilizando funcao (ou algo do tipo), e apenas define o tipo de retorno como vazio (void). Se o VisualG fosse seguir o padrão, seria algo assim: funcao NomeDaMinhaFuncao(parametro :tipo): vazio inicio fimFuncao Percebe? Procedimento é simplesmente uma função que não tem retorno nela mesmo! É bem mais simples esta estrutura assim.. Sobre o jogo da forca... dá para armazenar as palavras em vetores... segue um esboço para base: algoritmo "Teste palavras armazenadas em vetor" funcao LetraPosicao(c: caractere; p: inteiro): caractere inicio retorne Copia(c, p, 1) fimFuncao var vetPalavras: vetor [1..10] de caractere posPalavra: inteiro posLetra: inteiro inicio vetPalavras[1] <- "damasco" vetPalavras[2] <- "abacaxi" vetPalavras[3] <- "abacate" posPalavra <- Randi(3)+1 posLetra <- Randi(8)+1 escrevaL("Posição da palavra: ", posPalavra:1) escreval("Palavra na posição: ", vetPalavras[posPalavra]) escrevaL("Posicao da letra : ", posLetra:1) escrevaL("Letra na posição : ", LetraPosicao(vetPalavras[posPalavra], posLetra):1) fimAlgoritmo ...aos poucos vou tentar reformular esse código. Adendo: daí, daria por exemplo para deixar as palavras num arquivo de texto e o programa carregaria as palavras. Adendo 2: outra opção é utilizando "listas". Uma funcionalidade que existe no VisualG. Vide: Essas "listas" ficam no arquivo "listas.txt" lá na pasta doVisualG... Aí utilizam o comando ALEATORIO para utilizar... nesse tópico falo um pouco sobre: Por ai vai..

Exemplo resumido: algoritmo "Exercício com enquanto" // Descrição : Aqui você descreve o que o programa faz! (função) // Autor(a) : Nome do(a) aluno(a) // Data atual : 22/06/2021 var a, b: real continuar: logico opcao: caractere resultado: real inicio continuar <- VERDADEIRO //atencao: é sem aspas duplas mesmo enquanto (continuar) faca escreva ("Informe um numero: ") leia(a) escreva ("Informe um numero: ") leia(b) resultado <- a+b escreval("O resultado é:", resultado) escreva("Novo calculo (S/N)?") leia (opcao) se opcao = "N" entao continuar <- FALSO fimse escreval("") fimEnquanto escreva ("Fim dos Calculos.") fimAlgoritmo

Caro usuário, Seja bem-vindo ao Clube do Hardware. No intuito de servir como fonte de pesquisa no caso de instituições de ensino, informamos que incorrer no resolvimento por completo de questões relacionadas a disciplinas escolares de cursos técnicos e faculdades podem ser revistas e removidas pela Equipe de Moderação do Clube do Hardware. Para sanar dúvidas sobre esse tipo de problema, por gentileza, publique o passo a passo do desenvolvimento da questão, projeto, monografia ou conteúdo em dúvida para que possamos analisar se a resposta está correta ou não, ou para que possa ser auxiliado com a dúvida no desenvolvimento do exercício. Infelizmente, não há como resolver os trabalhos pelos usuários. O objetivo do Clube do Hardware é auxiliar seus usuários a encontrar soluções para que possam sanar suas dúvidas, e não de trazer soluções prontas para seus usuários. Além disso, copiar e colar respostas que não são de autoria própria do qualquer usuário é considerado plágio, o que é ilegal. Esperamos que compreenda. Atenciosamente, Equipe Clube do Hardware

@alaatreon6, você postou um código incompleto: Todo o código precisa está "semântico"... ou seja: meio que o "nome das coisas" remeterem ao que essas coisas são ou fazem... Já meio que está assim... Daí.. No caso, se "você precisa exibir os resultados", então "exiba os resultados". Onde estão os resultados? Oh! Lá... estão lá em r1 e r2. A função já foi feita assim... E onde indica se "existe ou não raízes"? Oh! Lá... Também. A própria função retorna o resultado. Veja um exemplo para servir como referência: procedimento ExibeRaizes(a, b, c: real) var r1, r2: real inicio se Raizes(a, b, c, r1, r2) entao escreval("As raizes são: ", r1:1:3, " e ", r2:1:3) senao escreval("Essa equação não possui raízes reais") fimSe fimProcedimento Não sei se você fez sozinho ou "copiou/usou como base" de outro código... mas aquele var ali na assinatura serve para passar o parâmetro por referência, assim, o que é alterado na variável local (r1 e r2) da função, também será refletida na variável que for utilizada para chamar a função (lá em ExibeRaizes()), ou seja: o r1 de Raizes() nada mais será que uma "referência" para r1 de ExibeRaizes(). ADENDO: espero que entenda que ambas as variáveis terem o mesmo nome seria apenas uma coincidência / conveniência... uma variável não tem nada a ver com a outra... poderiam ter quaisquer nomes... (Mas, por uma "boa semântica", ficaram com r1.) Quando não utiliza o var no parâmetro, a variável lá das funções ficam apenas como valor, ou seja: a variável da função recebe uma cópia do valor da variável (ou diretamente) que foi passado ao chamar a função... no caso, a, b e c em Raizes() teriam apenas uma cópia do valor de a, b e c que estão em ExibeRaizes()... que por sua vez, é uma cópia das variáveis a, b e c que estão lá no escopo global. Lembre: cada um desses 3 conjuntos de variáveis são distintos!!! Ficaram com a mesma nomenclatura por conveniência (e o VisualG permite), mas poderiam ter nomenclaturas completamente diferentes. Absorva isso: a única coisa que precisa ter em comum é ser de tipos compatíveis!!! ou seja: qualquer cosia que tenha um valor real iria servir... Exemplo: Eu posso fazer isso: exibeRaizes(3, 4, 1) Pois um inteiro é compatível com real... O valor 3 vai para variável local a de ExibiRaizes(), que eventualmente esse valor de a vai para o valor a de Raizes()... por aí vai. Qualquer dúvida é só perguntar.

Sobre: Pode ser que o fórum ou algum editor efetuou uma "autocorreção", mas o importante é que não use acentos em variáveis. EM RELAÇÃO AOS MENUS Entenda a diferença entre esses dois exemplos: ao finalizar uma dos casos (lá do escolha), eu inicio um novo menu; [Errado] ao finalizar uma dos casos (lá do escolha), eu volto para menu; [Certo] Você meio que estaria tentando fazer do modo 1 ou algo meio "estranho" (que não deveria funcionar!!!). Entretanto, uma forma mais correta seria fazer do modo 2. Resumidamente, ao terminar uma opção do menu, o programa deve eventualmente voltar para menu... O que é diferente de "invocar novamente menu já dentro de um caso" ou algo do tipo. Seria algo assim: algoritmo "Caixa Eletrônico v0.1" var opcao: inteiro aguardar: caractere procedimento menu() inicio escrevaL("------------------------------------") escrevaL("****BEM VINDO AO BANCO DO BOSTIL****") escrevaL("------------------------------------") escrevaL(" Digite [1] para depositar") escrevaL(" Digite [2] para efetuar saques") escrevaL(" Digite [3] para fazer pagamentos") escrevaL(" Digite [4] para contratar um empréstimo") escrevaL(" Digite [5] para converter moedas") escrevaL(" Digite [6] para encerrar") fimProcedimento inicio repita LimpaTela() menu() leia(opcao) escolha opcao caso 1 escrevaL("Entrou no caso 1") caso 2 escrevaL("Entrou no caso 2") caso 3 escrevaL("Entrou no caso 3") caso 6 escrevaL("Foi tarde!!!") outroCaso escrevaL("Caso ainda não tratado") fimEscolha escrevaL() escrevaL("Pressione qualquer ENTER para continuar!") leia(aguardar) ate (opcao = 6) fimAlgoritmo É possível também ler a opção no próprio procedimento. Exemplo: ... procedimento menu() inicio escrevaL("------------------------------------") escrevaL("****BEM VINDO AO BANCO DO BOSTIL****") escrevaL("------------------------------------") escreval(" Digite [1] para depositar") escrevaL(" Digite [2] para efetuar saques") escrevaL(" Digite [3] para fazer pagamentos") escrevaL(" Digite [4] para contratar um empréstimo") escrevaL(" Digite [5] para converter moedas") escrevaL(" Digite [6] para encerrar") leia(opcao) fimProcedimento inicio repita LimpaTela() menu() escolha opcao caso 1 escrevaL("Entrou no caso 1") caso 2 escrevaL("Entrou no caso 2") ... Ou utilizar um funcao que retorne o valor escolhido nela mesma.. Tanto faz*... vai da organização e padrões utilizados. Observe que o menu ficaria dentro de um laço de repetição... O VisualG funciona como um fluxo de passos... limpe a tela exiba o menu leia a opção selecione um caminho de acordo com a opção escolhida finalize o programa Como quero que fique repetindo: repita limpe a tela exiba o menu leia a opção selecione um caminho de acordo com a opção escolhida até que determinada condição seja correspondente finalize o programa O menu eventualmente reaparece porque o programa voltou para lá (foi estruturado para fazer isso)... o fluxo do programa se repete. Já da forma que você fez: Esse "escolha" aí solto estaria incorreto... não faço ideia porque o programa funciona! Bug sinistro! , mas de qualquer forma não está seguindo a sintaxe do VisualG (que é análogo ao do Pascal)... Se lá no "curso" tiver assim ou tiver alguma explicação, por favor me apresente. Adendo sobre a forma atual: Essa informações repassada para o "menu" não tem nada a ver com um menu... o menu seria apara para "listar as opções" mesmo. Esses dados seriam tratados em outro local... ou no programa principal (como está atualmente) ou, seguindo o suposto padrão, em um procedimento que trate desses dados (fique a vontade para reorganizar)... No programa principal: inicio repita LimpaTela() menu() escolha opcao caso 1 repita LimpaTela() escreval("Cédulas aceitas: 100, 50, 20") escreval("--------------------------------") escreval() escreva ("Digite o valor para depósito: ") leia(dep) saldo <- saldo + dep escrevaL() escreval("Depósito de R$", dep:1:2," efetuado.") escreval("--------------------------------") escreval("Saldo disponível R$", saldo:1:2) escreval("--------------------------------") escreva("Deseja fazer outra operação? [S/N]") leia(mais_dep) ate (mais_dep = "N") caso 2 escrevaL("Entrou no caso 2") Quando mais_dep for igual a "N", vai sair do repita interno... como não tem nada mais dentro do caso 1 o programa vai para próxima linha após fimEscolha... (ele não passado caso 2 como imaginável) e lá no outro ate, como opcao eventualmente está com 1 (que é diferente de 6), vai voltar lá para o respectivo repita lá em cima... que por sua vez vai limpar a tela... exibir o menu... etc, ou seja: o fluxo se repete... Sobre: Acho que poderia ficar assim: se (dep%20 = 0) OU (dep%50 = 0) OU ((dep > 50) E (dep-50%20=0)) entao Sobre: Não sei se também foi ensinado isso, mas esta estrutura estaria errada... só deveria existir um fimAlgoritmo no código. Simplesmente deixe o fluxo continuar até que chegue no fimAlgoritmo lá de baixo como no meu exemplo. Adendo: no Pascal, o pai do VisualG, para finalizar o programa, existe o end. E também existe outros comandos como o exit() e o halt()... que meio que serviriam para fazer da forma que você tentou fazer no VisualG... entretanto NÃO existe (desconheço) comando equivalente no VisualG.... RESUMINDO: mesmo lá no Pascal, não seria recomendado utilizar esses comandos... e, como no VisualG sequer existe, não teria como fazer da forma que você fez. (Mas estou aberto à discussão sobre) Qualquer dúvida é só postar.

Os valores para variáveis lógicas não tem as aspas duplas. Vide: algoritmo "Condição de existência de um triândulo" var a, b, c: inteiro l1, l2, l3: logico inicio escreval("Informe os lados A, B e C : ") leia(a, b, c) l1 <- a < b+c l2 <- b < a+c l3 <- c < a+b se ((l1 = VERDADEIRO) e (l2 = VERDADEIRO) e (l3 = VERDADEIRO)) entao escreval("É um triangulo") senao escreval("Não é possivel formar um triangulo") fimSe fimAlgoritmo Como a própria variável já retorna um valor lógico, pode usar o valor direto.

Na verdade não... o problema é que a variável C foi declarada com o tipo LOGICO, mas no enquanto está tentando comparar com um conjunto de CARACTERES: Não dá para comparar um tipo logico com um tipo caractere, ou seja: são tipos incompatíveis entre si. (Era para dar erro, mas o VisualG tem alguns bugs ) O erro principal está no uso dessas aspas duplas... o correto seria algo assim: Para eu ser mais objetivo, segue uns exemplos: 1.0 VERSÂO SIMPLES DE UMA SOMA (sem repetições) algoritmo "Exercício de repetição" //Escreva um algoritmo para ler dois valores. Após a leitura deve-se calcular //a soma dos valores lidos e armazená-la em uma variável. Após o cálculo da //soma, escrever o resultado e escrever também a pergunta 'Novo Cálculo (S/N)?'. //Deve-se ler a resposta e se a resposta for 'S' (sim), deve-se repetir todos //os comandos (instruções) novamente, mas se a resposta for 'N' (não), o // algoritmo deve ser finalizado escrevendo a mensagem 'Fim dos Cálculos'. var a: real b: real soma: real inicio escreval("Informe o primeiro valor: ") leia(a) escreval("Informe o segundo valor: ") leia(b) soma <- a + b escreval("Resultado da somas dos valores:", soma) fimAlgoritmo 2.1 VERSÃO DE SOMAS COM REPETIÇÃO (enquanto) algoritmo "Exercício de repetição" //Escreva um algoritmo para ler dois valores. Após a leitura deve-se calcular //a soma dos valores lidos e armazená-la em uma variável. Após o cálculo da //soma, escrever o resultado e escrever também a pergunta 'Novo Cálculo (S/N)?'. //Deve-se ler a resposta e se a resposta for 'S' (sim), deve-se repetir todos //os comandos (instruções) novamente, mas se a resposta for 'N' (não), o // algoritmo deve ser finalizado escrevendo a mensagem 'Fim dos Cálculos'. var a: real b: real soma: real resp: caractere inicio enquanto (resp <> "N") faca escreval("Informe o primeiro valor: ") leia(a) escreval("Informe o segundo valor: ") leia(b) soma <- a + b escreval("Resultado da somas dos valores:", soma) escreval("Novo Cálculo (S/N)?") leia(resp) fimEnquanto escreval("Fim dos Cálculos") fimAlgoritmo 2.2 VERSÃO DE SOMAS COM REPETIÇÃO (repita) algoritmo "Exercício de repetição" //Escreva um algoritmo para ler dois valores. Após a leitura deve-se calcular //a soma dos valores lidos e armazená-la em uma variável. Após o cálculo da //soma, escrever o resultado e escrever também a pergunta 'Novo Cálculo (S/N)?'. //Deve-se ler a resposta e se a resposta for 'S' (sim), deve-se repetir todos //os comandos (instruções) novamente, mas se a resposta for 'N' (não), o // algoritmo deve ser finalizado escrevendo a mensagem 'Fim dos Cálculos'. var a: real b: real soma: real resp: caractere inicio repita escreval("Informe o primeiro valor: ") leia(a) escreval("Informe o segundo valor: ") leia(b) soma <- a + b escreval("Resultado da somas dos valores:", soma) escreval("Novo Cálculo (S/N)?") leia(resp) ate resp = "N" escreval("Fim dos Cálculos") fimAlgoritmo Adendo: usar enquanto ou repita vai de acordo com o gosto ou praticidade... tudo que faz com um, dá para fazer com um outro... Daí, caso queira implementar usando uma variável lógica, poderia ser como sugerido pelo @devair1010: Ou seja: nos meus exemplos, o resp está declarado como caractere, daí eu fiz comparações com caracteres mesmo (caractere x caractere). Lá diretamente no enquanto... já declarando o resp como logico no exemplo acima, a comparação está sendo feita com um valor lógico (lógico x lógico), ou seja: primeiro foi necessário utilizar um se para verificar se foi informado um "n" (que é um caractere... - não dá para enviar um direto lógico do teclado), daí "insere o valor FALSO" na variável (esse valor NÃO é um caractere), que posteriormente vai ser comparada lá no enquanto. Segue um exemplo: algoritmo "Exercício de repetição" //Escreva um algoritmo para ler dois valores. Após a leitura deve-se calcular //a soma dos valores lidos e armazená-la em uma variável. Após o cálculo da //soma, escrever o resultado e escrever também a pergunta 'Novo Cálculo (S/N)?'. //Deve-se ler a resposta e se a resposta for 'S' (sim), deve-se repetir todos //os comandos (instruções) novamente, mas se a resposta for 'N' (não), o // algoritmo deve ser finalizado escrevendo a mensagem 'Fim dos Cálculos'. var a: real b: real resultado: real opcao: caractere continuar: logico inicio continuar <- VERDADEIRO enquanto (continuar = VERDADEIRO) faca escreva ("Informe um numero:") leia(a) escreva ("Informe um numero:") leia(b) resultado <- a+b escreval("O resultado é:", resultado) escreva ("Novo calculo (S/N)?") leia(opcao) se opcao = "n" entao continuar <- FALSO fimSe fimEnquanto fimAlgoritmo Adendo: observe que não precisa verificar se digitou "s", pois da forma que foi implementado, a variável continuar vai ficar com VERDADEIRO até que digite um "n". O comando enquanto funciona assim: se o que estiver entre o enquanto e o faca equivaler a VERDADEIRO, o enquanto vai executar mais uma vez. Mas se equivaler a FALSO, o enquanto vai parar e o programa continuará a partir da próxima linha após o fimEnquanto correspondente. Então, a própria variável lógica já resulta em VERDADEIRO ou FALSO, né? Então poderia ficar assim: Segue exemplo num código: algoritmo "Exercício de repetição" //Escreva um algoritmo para ler dois valores. Após a leitura deve-se calcular //a soma dos valores lidos e armazená-la em uma variável. Após o cálculo da //soma, escrever o resultado e escrever também a pergunta 'Novo Cálculo (S/N)?'. //Deve-se ler a resposta e se a resposta for 'S' (sim), deve-se repetir todos //os comandos (instruções) novamente, mas se a resposta for 'N' (não), o // algoritmo deve ser finalizado escrevendo a mensagem 'Fim dos Cálculos'. var a: real b: real resultado: real opcao: caractere continuar: logico inicio continuar <- VERDADEIRO enquanto (continuar) faca escreva ("Informe um numero:") leia(a) escreva ("Informe um numero:") leia(b) resultado <- a+b escreval("O resultado é:", resultado) escreva ("Novo calculo (S/N)?") leia(opcao) se opcao = "n" entao continuar <- FALSO fimSe fimEnquanto fimAlgoritmo

Exemplo para retornar um quarteto de números: program Soma_34; var x, y, z, w: integer; begin Randomize(); repeat x := Random(16)+1; y := Random(16)+1; z := Random(16)+1; w := Random(16)+1; until (((x <> y) and (x <> z) and (x <> w) and (y <> z) and (y <> w) and (z <> w)) and (x+y+z+w = 34)); writeln(x:3, y:3, z:3, w:3); end. Exemplo pressionando qualquer tecla para gerar um novo quarteto (ESC para sair): program Soma_34; uses CRT; var x, y, z, w: integer; tries: integer; begin Randomize(); while (ReadKey() <> #27) do begin tries := 0; repeat Inc(tries); x := Random(16)+1; y := Random(16)+1; z := Random(16)+1; w := Random(16)+1; until (((x <> y) and (x <> z) and (x <> w) and (y <> z) and (y <> w) and (z <> w)) and (x+y+z+w = 34)); writeln(x:3, y:3, z:3, w:3, 'tentativas: ':20, tries); end; end. Exemplo gerando um quarteto a cada 500 milissegundos: program Soma_34; uses CRT; var x, y, z, w: integer; tries: integer; begin Randomize(); while (not KeyPressed()) do begin tries := 0; repeat Inc(tries); x := Random(16)+1; y := Random(16)+1; z := Random(16)+1; w := Random(16)+1; until (((x <> y) and (x <> z) and (x <> w) and (y <> z) and (y <> w) and (z <> w)) and (x+y+z+w = 34)); Delay(500); writeln(x:3, y:3, z:3, w:3, 'tentativas: ':20, tries); end; end.

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 Sugiro antes de tentar resolver o problema do "Jogo da Forca", fazer exercício mais simples. A ideia é ir se acostumando com a sintaxe do VisualG com lógicas menos elaboradas e ir evoluindo. Exemplo de exercícios: Exemplos de soluções: (para executar um código no VisualG, vá no menu Run (executar)/Rodar o algoritmo - ou pressione F9) : 1) Escreva um programa que mostre na tela a mensagem "Olá, Mundo!" Resposta: 2) Faça um programa que leia o nome de uma pessoa e mostre uma mensagem de boasvindas para ela: Ex: Qual é o seu nome? João da Silva Olá João da Silva, é um prazer te conhecer! Resposta: Por aí vai.

Para contextualizar.... provavelmente estaria usando o PascalZim, correto? Sobre: Teste no PascalZim 6.0.3.1 e deu esse mesmo erro: Sobre: Não, só para deixa claro: o problema não foi a falta de apóstrofos. Isso seria apenas "mais um outro problema". O erro ali foi que faltou um end; do case. Veja: Inseri o end; e passou a dar outro erro. Sacou? Os erros seguintes são mais claros, como [1] esse que é para usar =, em vez de :=; [2] apagar esse end;, mais abaixo, que provavelmente era o do case; [3] passar a usar o apóstrofo nas opções do case, já que estaria comparando com um "caractere", e não com uma "variável"; [4] usar cont em vez de i lá no caso 'A'. Dica 1: sempre mantenha o código indentado. No PascalZim, basta pressionar Ctrl+i para dar um ajuda. Dica 2: esses end do case ficam meio soltos mesmo... como sugestão, recomendo deixar sempre um comentário como esse ao lado dele. Se quiser extrapolar, ficaria bom também coloca um comentário para cada end dos casos. Ex.: