Ir ao conteúdo
  • Cadastre-se

Simon Viegas

Membro VIP
  • Posts

    3.939
  • Cadastrado em

  1. Adendo inicial: sugiro não copiar os códigos de um modo geral, mas sim apenas tomar como referência e ir digitando manualmente... Para facilitar os testes, retire as leituras dos dados: //para linha <- 1 ate 4 faca // para coluna <- 1 ate 4 faca // escreval("Informe a ", coluna:1, "º nota do ", coluna:1, "º bimestre de ", materias[linha]) // leia(notasBimestres[linha,coluna]) // fimPara //fimPara Ah! Não precisaria de um vetor para o número do bimestre: De: Para algo como: para linha <- 1 ate 4 faca escreva (" ", linha:1, "º bimestre") fimPara Ficando com algo assim: algoritmo "notasQuatroBimestres" var notasBimestres : vetor [1..4,1..4] de real linha, coluna : inteiro materias : vetor [1..4] de caractere inicio materias[1] <- "matemática" materias[2] <- "português" materias[3] <- "geografia" materias[4] <- "história" //para linha <- 1 ate 4 faca // para coluna <- 1 ate 4 faca // escreval("Informe a ", coluna:1, "º nota do ", coluna:1, "º bimestre de ", materias[linha]) // leia(notasBimestre[linha,coluna]) // fimPara //fimPara para linha <- 1 ate 4 faca escreva(" ", linha:1, "º bimestre") fimpara para linha <- 1 ate 4 faca escreval() escreva (materias[linha]) para coluna <- 1 ate 4 faca escreva (" ", notasBimestre[linha,coluna]:12) fimPara escreval() fimPara fimAlgoritmo Inserindo a base do código do @Midori: algoritmo "notasQuatroBimestres" var notasBimestres : vetor [1..4,1..4] de real linha, coluna : inteiro materias : vetor [1..4] de caractere inicio materias[1] <- "matemática" materias[2] <- "português" materias[3] <- "geografia" materias[4] <- "história" //para linha <- 1 ate 4 faca // para coluna <- 1 ate 4 faca // escreval("Informe a ", coluna:1, "º nota do ", coluna:1, "º bimestre de ", materias[linha]) // leia(notasBimestres[linha,coluna]) // fimPara //fimPara escreva (" ":12) para linha <- 1 ate 4 faca escreva (linha:1, "º bimestre":12) fimpara para linha <- 1 ate 4 faca escreval() escreva (materias[linha]:11) para coluna <- 1 Ate 4 Faca escreva (notasBimestres[linha, coluna]:12:2) fimPara fimPara fimAlgoritmo Vá tentando na marra... vai fazendo testes até que saia algo que agrade. Isso é bom para ir se acostumando com os comportamentos da tela. Exemplo, insere uns: escrevaL("------------------------------------------") Para as colunas, inserir uns "|". Vai futucando... A ideia do exercício é justamente treinar "vestir a roupa de sapo e dar seus pulos". Basicamente o número à direita dos ":" define o mínimo de espaço que o conteúdo à esquerda dos ":" vai ocupar na tela, ou seja, se um texto tiver, por exemplo, 5 caracteres, o VisualG vai inserir mais 7 espaços para que ocupe 12. Se for caractere, insere á direita (alinhado à esquerda). Se for número, insere à esquerda (alinhado à direita). A dica é a mesma: faça testes! Exemplo: Para também auxiliar no entendimento, dá uma pesquisada sobre "formatação visualg" no Google... e vai pescando ideias... PS: e quando for número real, como no exemplo: idem: vai fazendo testes até compreender.
  2. Pronto! Já temos um norte! "Os resultados estão dando 0". Poderia ter mandando um print da tela para analisar melhor, mas vamos lá... Peguei o código e inseri os dados da primeira linha dos testes: Não saiu zerado. Provavelmente está informando os dados errados: Exemplo informando errado: Aí vai sair zerado mesmo...
  3. Sim..., mas comece pelo que foi informado. Está dizendo que não foi encontrada a posição 0 do vetor nome. Como visto, não existe a posição 0. Só corrigir: procedimento cadastrarProduto () inicio se (quantidadeProdutos < 100) então quantidadeProdutos <- quantidadeProdutos+1 escreva ("Digite o nome do produto: ") leia(nome[quantidadeProdutos]) escreva ("Digite o código do produto: ") leia(codigo[quantidadeProdutos]) escreva ("Digite o valor do produto: ") leia(valor[quantidadeProdutos]) escrevaL("Produto cadastrado com sucesso!") senao escrevaL("Limite de produtos atingido. Não é possível cadastrar mais produtos.") fimse fimProcedimento
  4. O que está dando errado? Para achar uma solução de um problema, é preciso definir qual é o problema... Para adiantar, sugiro o seguinte: crie uma planilha com os dados dos testes e adicione também os respectivos resultados esperados, algo como: Aí executar o programa e compara os dados... Identifique qual problema seria e busca corrigir. Se for outra coisa, tenta demonstrar o que é... Adendo: Sugiro deixar na ordem do enunciado, ou seja, o turno vem antes da categoria. Adendo 2: Essa validação não faz parte do enunciado, basta remover.
  5. É normal. Os nomes são sorteados. Como existiam poucas opções, as chances de repetir são maiores. Uma alternativa seria cadastrar mais nomes. Obs.: o algoritmo de sorteio no VisualG não é bom de qualquer forma, mas não precisa se apegar a esse detalhe (de repetições). A ideia central seria ter contato com o recurso. Pode ser útil para facilitar testes, por exemplo... Muito mais prático que ficar digitando valores cada vez.
  6. Show! Só um detalhe: ao informar um nome de produto inexistente, o programa "não faz nada". Poderia dar uma arrumada nisso.
  7. Depende. Deixaria mais organizado... Se onde o exercício foi proposto já estudou registros, sim. Se for um exercício onde está estudando registro, tem a obrigação de usar... Caso contrário, não... ou crie duas versões diferentes. Uma coisa não substitui a outra, pelo contrário, geralmente são utilizadas em conjunto. Dê uma pesquisada sobre registros no VisualG e se aprofunde no tema. Após, aplique o que aprendeu (e vai aprendendo). Sobre o código atual usando apenas vetores... para mim está muito bom. Só inseria o registro. Adendo 1: Segue código modificado utilizando dois novos* conceitos: valores aleatórios e listas. (O segundo está relacionado ao primeiro.) algoritmo "Análise Das Notas Da Turma v0.2_auto" var nome : vetor [1..4] de caractere nota1 : vetor [1..4] de real nota2 : vetor[1..4] de real mediaAluno : vetor [1..4] de real contador : inteiro somaMedia, mediaTurma : real qtdAlunosAcimaDaMediaDaTurma : inteiro procedimento espera (pularLinha:logico) //veja a magia da organização de códigos. Basicamente copiei esse código de //outro tópico aqui do fórum //...apenas inseri essa opção de pular a linha, ou seja, já criando uma nova //versão alternativa para esse recurso var entrada:caractere inicio escreva ("Pressione enter para continuar...") se (pularLinha) então escrevaL("") fimSe leia(entrada) fimProcedimento inicio somaMedia <- 0 para contador <- 1 ate 4 faca escrevaL("Informe os dados do ", contador:1, "º aluno") ALEATORIO ON LISTA "NOMES DE PESSOAS escreva (" Nome : ") leia(nome[contador]) escreva (" 1º nota: ") ALEATORIO 0,10 leia(nota1[contador]) escreva (" 2º nota: ") leia(nota2[contador]) ALEATORIO OFF mediaAluno[contador] <- (nota1[contador]+nota2[contador])/2 somaMedia <- somaMedia+mediaAluno[contador] escrevaL("") fimPara mediaTurma <- somaMedia/4 espera(FALSO) limpaTela() escrevaL("Listagem de alunos :") escrevaL("Nome":16, "Nota") escrevaL("--------------------") qtdAlunosAcimaDaMediaDaTurma <- 0 para contador <- 1 ate 4 faca escrevaL(nome[contador]:15, "|", mediaAluno[contador]:5:2) se (mediaAluno[contador] > mediaTurma) então qtdAlunosAcimaDaMediaDaTurma <- qtdAlunosAcimaDaMediaDaTurma+1 fimSe fimPara escrevaL("") escrevaL("Ao todo temos ", qtdAlunosAcimaDaMediaDaTurma:1, " aluno(s) que está(ão) acima da média da turma, que é ", mediaTurma:4:2, ".") fimAlgoritmo Telas: Adendo 2: não, não nos pergunte como configurar as listas. PESQUISE!!! No aguardo.
  8. No caso: System.out.println("Seu sistema está em " + idioma); Seria equivalente a: System.out.print("Seu sistema está em "); System.out.println(idioma);
  9. Do que entendi, você está usando os valores lógicos. O se está utilizando o valor retornado pela função. Pra mim ficou correto, sim. Tá muito bom! Para exemplificar uma nova possível simplificação: DE: Observe que um código é bem parecido com o outro... daí poderia remover esse "código repetido", deixando a estrutura de busca em apenas um local. PARA: funcao produtoExiste (nome:caractere) : logico var resultado : logico inicio resultado <- FALSO se (buscaPosicaoProduto(nome) > 0) então escrevaL("Já existe um produto com o nome '", nome, "' no cadastro!") existe <- VERDADEIRO fimSe retorne resultado fimFuncao funcao buscaPosicaoProduto(nome:caractere) : inteiro var resultado : inteiro contador : inteiro inicio resultado <- 0 para contador <- 1 ate qtdProdutos faca se (nome = produtos[contador].nome) então resultado <- contador interrompa() fimse fimPara retorne resultado fimFuncao Ou seja: a busca pela posição já indica se existe ou não... assim reaproveita o que já tem, em vez de "duplicar o código". O produtoCadastrado() pode seguir a mesma lógica.
  10. @dmoret, entre usar se, ou se/senao ou escolha, conceitualmente falando, você meio que deve utilizar aquilo que está sendo estudado no momento, ou seja, se foi um exercício de se/senão, utilize ele mesmo! Não faria sentido utilizar outra coisa, mesmo que eventualmente fique até melhor... Se já estudou os 3 e está em aberto, na ordem do "mais adequado para o menos adequado", seria: escolha, depois se/senao e em último caso um conjunto de se. A ideia seria justamente essa... entende-se bem o se/senão.. Daí, quando estudar escolha, vai entender melhor quando utilizar um ou outro... É como uma evolução.. Sobre o erro apresentado, existem basicamente dois probleminhas: todo se tem o seu respectivo fimse, daí faltou usá-los. O VisualG leu todos linhas até chegar no fim do código e não encontrou... e acusa o erro. devido a uma limitação técnica, o se e senao não podem ficar na mesma linha aqui no VisualG (na maioria das outras linguagem principais podem... Inclusive no Pascal, pai do VisualG). Mesmo que venha a funciona e aparentar está funcionando, estará com a sintaxe errada!!! (Tem que colocar em linhas separadas.) Dica 1: ao iniciar um se, já insere o respectivo fimSe abaixo. Depois preenche o conteúdo. Isso ajuda a não esquecer ou se perder quando o código começar a ficar grande. Exemplo: Implementa a base: se categoria = "1" então fimSe Observe que já deixa uma linha em branco no meio... Depois vai preenchendo: se categoria = "1" então vlr_diaria <- 299.99 escreval("Categoria: Popular") fimSe Insere o senao.. Depois o conteúdo do senao, que nesse caso eventualmente é outro se: se categoria = "1" então vlr_diaria <- 299.99 escreval("Categoria: Popular") senao se categoria = "2" então fimSe fimSe Preenche o novo se. se categoria = "1" então vlr_diaria <- 299.99 escreval("Categoria: Popular") senao se categoria = "2" então vlr_diaria <- 399.99 escreval("Categoria: Hatch ou Sedan Intermediário") fimSe fimSe Por aí vai. Dica 2: quando tiver implementando, pressione Ctrl+G para indentar o código. Se tiver faltando um fimse, o código ficará todo desalinhado. Corrigindo ficaria algo assim: var categoria: caractere tipoc: caractere diarias: inteiro vlr_diaria: real vlr_total: real desconto: real inicio escreval("Escolha a categoria do veículo (1, 2 ou 3): ") leia(categoria) escreval("Digite a qtd de diárias: ") leia(diarias) se categoria = "1" então vlr_diaria <- 299.99 escreval("Categoria: Popular") senao se categoria = "2" então vlr_diaria <- 399.99 escreval("Categoria: Hatch ou Sedan Intermediário") senao se categoria = "3" então vlr_diaria <- 499.99 escreval("Categoria: SUV ou Sedan Luxo") fimse fimse fimse escreval("Tipo Categoria: ", tipoc) escreval("Qtd de diárias: ", diarias) escreval("Vlr da diária: R$ ", vlr_diaria) se diarias <= 6 então desconto <- 0 senao se diarias <= 14 então desconto <- 0.05 senao se diarias <= 30 então desconto <- 0.1 fimse fimse fimse vlr_total <- diarias * vlr_diaria * (1 - desconto) escreval("Valor total do aluguel: R$ ", vlr_total) fimalgoritmo Adendo: provavelmente dentro lá de cada se, seria para definir o valor de tipoc, em vez já escrever a resposta... O que deve fazer ou não vai depender do enunciado... Pode ser que seria algo como: se categoria = "1" então vlr_diaria <- 299.99 tipoc <- "Popular" senao se categoria = "2" então vlr_diaria <- 399.99 tipoc <- "Hatch ou Sedan Intermediário" senao se categoria = "3" então vlr_diaria <- 499.99 tipoc <- "SUV ou Sedan Luxo" fimse fimse fimse Adendo 2: O escolha funciona como um se/senao, no caso eles são específicos para condições mutuamente excludentes, ou seja, aqueles casos em que "se for uma coisa, não pode ser outra"... A ideia é que neles, se uma condição for verdadeira, o programa já pula para o fim da estrutura... não perdendo tempo verificando se outra coisa. Já no caso de um conjunto de se, independente da categoria escolhida, sempre vai verificar todas as condições (opção menos adequada para o contexto).
  11. @Eli Almeidaa, o algoritmo está muito bom! Show de bola! Complementando, segue algumas dicas/sugestões/revisões gerais de pequenos detalhes. Aí pode ir analisando e implementando o que achar que faz sentido, ou não: Vou tentar exemplificar sem explicar muito, pois costumo ser muito prolixo... De: Para: retorno <- FALSO FALSO e VERDADEIRO são constantes... De: Para: se (não vetorCheio()) então Daí a mesma lógica para outras estruturas semelhantes. Simplificando o cadastrarProduto() pela lógica do restante do algoritmo: De: Para: se (não vetorCheio()) então repita escrevaL("Informe o nome do produto") leia(novoProduto.nome) produtoJaExiste <- produtoExiste(novoProduto.nome) se (não produtoJaExiste) então escrevaL("Informe o preço do produto") leia(novoProduto.preco) escrevaL("Informe o estoque do produto") leia(novoProduto.estoque) qtdProdutos <- qtdProdutos+1 produtos[qtdProdutos] <- novoProduto escrevaL("Produto cadastrado com sucesso") fimSe ate (não produtoJaExiste) fimSe De Para: funcao vetorVazio() : logico var retorno : logico inicio retorno <- FALSO se (qtdProdutos <= 0) então escrevaL("Não há produtos cadastrados") retorno <- VERDADEIRO fimSe retorne retorno fimFuncao Já que temos vetorCheio()... Pode fazer mais sentido. Caso queira alterar, poderia utilizar o Ctrl+U. E ir alterando um por um. Lembrando que o valor lógico estaria invertido, teria que também ajustar a lógica. Exemplo: De: Para: se (não vetorVazio()) então escrevaL("Produtos cadastrados :") De: Observe que não há um "novo produto" nesse contexto... Para: procedimento consultarEstoque() var nomeProduto : caractere posProduto : inteiro inicio se (não vetorVazio()) então escrevaL("Informe o nome do produto que gostaria de consultar o estoque") leia(nomeProduto) posProduto <- buscaPosicaoProduto(nomeProduto) se (posProduto > 0) então escreval(" O estoque de ", produtos[posProduto].nome, " é ", produtos[posProduto].estoque:1) fimSe fimse fimProcedimento ou procedimento consultarEstoque() var nomeProduto : caractere posProduto : inteiro dbProduto : t_Produto inicio se (não vetorVazio()) então escrevaL("Informe o nome do produto que gostaria de consultar o estoque") leia(nomeProduto) posProduto <- buscaPosicaoProduto(nomeProduto) se (posProduto > 0) então dbProduto <- produtos[posProduto] escreval(" O estoque de ", dbProduto.nome, " é ", dbProduto.estoque:1) fimSe fimse fimProcedimento Adendo: infelizmente o VisualG NÃO PERMITE retornar um registro por uma função. Algo assim: funcao buscaProduto(nome:caractere) : t_Produto Mas consegue compreender como isso seria útil para esse ou outros contextos? Infelizmente não rola! Até dá para fazer um malabarismo utilizando uma variável global, mas acho meio deselegante, para não dizer: armengue . Veja: var produtos : vetor [1..QTD_MAX_PRODUTOS] de t_Produto opcao, qtdProdutos : inteiro retornoProduto : t_Produto Aí a função poderia ficar: funcao buscaProdutoPorNome (nome:caractere) : logico var posProduto : inteiro retorno : logico inicio retorno <- FALSO posProduto <- buscaPosicaoProduto(nome) se (posProduto > 0) então retornoProduto <- produtos[posProduto] //aqui utilizando uma variável global para superar a limitação do VisualG retorno <- VERDADEIRO fimSe retorne retorno fimFuncao E usar algo como: procedimento consultarEstoque() var nomeProduto : caractere posProduto : inteiro dbProduto : t_Produto inicio se (não vetorVazio()) então escrevaL("Informe o nome do produto que gostaria de consultar o estoque") leia(nomeProduto) se (buscaProdutoPorNome(nomeProduto)) então dbProduto <- retornoProduto //esse variável à direita foi atulizada na função acima escreval(" O estoque de ", dbProduto.nome, " é ", dbProduto.estoque:1) fimSe fimse fimProcedimento ***Assim como no teu código original, não está sendo tratado a questão do comportamento do que fazer caso não encontre o produto... precisa pensar em algo.*** Por aí vai... tem mais coisa que por ir futucando e "melhorando". Exemplo: produtos[buscaPosicaoProduto(novoProduto.nome)].estoque <- produtos[buscaPosicaoProduto(novoProduto.nome)].estoque+quantidade Para evitar ficar chamando a função de busca várias vezes, como já citado, copia o valor: posProduto <- buscaPosicaoProduto(novoProduto.nome) Vá tentado refinar o código por completo. Aí se tiver dúvidas posta, ou posta o código completo atual para podermos analisar outros "pequenos detalhes".
  12. O comando inicio, relacionado ao programa principal, deve ficar após as funções e procedimento. Aproveitando a postagem: Essas duas variáveis são locais. A primeira melhor declarada dentro da função que a usa. A segunda já está declarada na assinatura do método, ou seja, declarando aí, está simplesmente duplicando, mas se qualquer forma, o enunciado sugere que envie um texto diretamente (utilizando aspas duplas). Vejam como é a chamada do procedimento: Mas no código está utilizando a variável global msg. Observe que no momento dessa chamada, essa variável está em branco... pois o programa acabou de ser iniciado. Estaria "funcionando" pois o texto está fixo lá dentro do procedimento, vejam: Resumindo: o texto precisa vir de fora, daí utiliza a variável msg (que está na assinatura do procedimento) para tal. Exemplo: procedimento gerador (msg:caractere; repeticao, borda_tipo:inteiro) var contador : inteiro inicio borda(borda_tipo) para contador de 1 ate repeticao faca escreval(msg) fimPara borda(borda_tipo) fimProcedimento Exemplo de chamada: inicio gerador("Portugol Studio", 3, 1) gerador("Portugol Studio", 3, 2) gerador("Portugol Studio", 3, 3) fimAlgoritmo Segue um código completo: algoritmo "Exercício 89" //PROPOSTA: Crie um programa que melhore o procedimento gerador() da questão anterior //para que o programador possa escolher uma entre as três bordas //+-------=======-------+ Borda1 //~~~~~~~:::::::~~~~~~~~ Borda2 //<<<<<<<------->>>>>>> Borda3 //Ex: Uma chamada válida seria Gerador("Portugol Studio",3,2) // ~~~~~~~:::::::~~~~~~~~ // Portugol Studio // Portugol Studio // Portugol Studio // ~~~~~~~:::::::~~~~~~~~ //Autora: Franciele Juchem Santiago //Prof: Gustavo Guanabara //Data:15/04/2023 const BORDA1 = 1 BORDA2 = 2 BORDA3 = 3 var //Obs.: devido a um bug do VisualG, necessário deixar o comando var, mesmo //que não tenha variáveis globais (versão 3.6.0.5) procedimento borda (borda_tipo:inteiro) inicio escolha (borda_tipo) caso BORDA1 escreval("+-------=======------+") caso BORDA2 escreval("~~~~~~~~:::::::~~~~~~~") caso BORDA3 escreval("<<<<<<<<------->>>>>>>") fimEscolha fimProcedimento procedimento gerador (msg:caractere; repeticao, borda_tipo:inteiro) var contador : inteiro inicio borda(borda_tipo) para contador de 1 ate repeticao faca escreval(msg) fimPara borda(borda_tipo) fimProcedimento inicio gerador("Portugol Studio", 3, 1) gerador("Portugol Studio", 3, 2) gerador("Portugol Studio", 3, 3) fimAlgoritmo
  13. Assim..., não seria "a" forma mais correta, seria apenas "umas" sugestões. Seria tentar seguir uma lógica geral e mais uniforme. Isso. A proposta é que o código sempre faça o maior sentido possível. Buscar ser coerente. Pois a medida que o código vai crescendo, mais complicado ficará para entender todo o código, ou seja, tendo uma coerência geral, fica mais fácil deduzir "o que seria" cada coisa. E se uma coisa não existir, você já entenderá mais facilmente o que precisaria ser feito. Veja o código abaixo: A função chama-se "produtoExiste", mas analisando o código verificam-se que na verdade ela serve para "retornar a posição do vetor onde está o produto que contenha aquele nome". Entende a diferença? Ela tem uma nomenclatura que indica uma coisa, mas está fazendo outra função (objetivo) diferente. Fica estranho. Quando mais coerente, mais simples vai ficar... Apenas ajuste a função. Em vez de retornar a posição, fazer o que tem que fazer: retornar se existe ou não. Veja: "Estou verificando se algo existe, logo espero que me retorne se existe ou não". Tem também a questão de "onde colocar a mensagem de erro". Aí dê uma olhada na minha postagem anterior no trecho citado abaixo: Observe que essa característica de "retornar a posição de um produto" poderia ser útil, por exemplo, na hora de atualizar. Aí só aproveitar: funcao buscaPosicaoProduto(nome:caractere):inteiro var resultado : inteiro contador : inteiro inicio resultado <- 0 para contador <- 1 ate quantidadeProdutosCadastrados faca se (nome = produtos[contador].nome) então resultado <- contador interrompa() fimse fimPara retorne resultado fimFuncao Ou seja: passando o nome, já terá a posição no vetor que precisar atualizar o produto. Se não achar, vai retornar 0. CORREÇÕES IMPORTANTES: 1. iniciando com a quantidade correta Lembre-se da coerência!!! Oras! se não tem nenhum produto cadastrado, como raios vai começar com 1? Tem que ser com 0!!! . (Daí tem que ajustar todo restante do código onde possa ter efeito.) 2. Corrija o malabarismo da função de listar Para visualizar a complexidade da coisa: y recebe a quantidade de produtos, depois a quantidade de produtos do programa em si passa ser 1, depois verifica se tem um produto "sem nome" existe no vetor, depois está verificando se o resultado (da existência) retornou especificamente 0, e que ao mesmo tempo essa mesma variável seja diferente de 1 (se é 0, necessariamente será diferente de 1)..... O que você queria verificar? Seria "se existe algum produto cadastrado"?... Logo, seria só verificar a quantidade de produtos: procedimento listarProdutos() var contador : inteiro inicio se (quantidadeProdutoscadastrados > 0) então escrevaL("Não há produtos cadastrados") senao escrevaL("Produtos cadastrados :") para contador <- 1 ate qtdProdutos faca escrevaL("Nome : ", produtos[contador].nome) escrevaL("Preço : R$ ", produtos[contador].preco:1:2) escrevaL("Estoque : ", produtos[contador].estoque:1) escrevaL() fimPara fimSe fimProcedimento Daí, só criei uma função para deixar mais organizado e elegante: Adendo: no código acima também entra a questão de "onde deixar a mensagem de erro" (que citei que tem na postagem anterior), ou seja, pedi para verificar se existe ou não produtos, e a mensagem ficou fora da função que verifica. Se tiver 10 lugares diferentes que chama essa função e precisar de uma mensagem de erro, teria que escrever 10 vezes a mensagem. Se precisa modificar a mensagem, teria que modificar 10x... se deixar dentro da própria função, aí ficaria centralizado só lá. Só reler a postagem anterior também. Vai analisando e deixando da forma que fique mais organizada... lembrando-se sempre de manter um padrão uniforme para as funções. Conteúdo da função existemProdutosCadastrados: Tudo é uma questão de entender os contextos... essa função poderia se chamar "listaVazia()" ou algo do tipo, por exemplo... nesse caso o resultado seria invertido ("se é maior que 0, então é FALSO") e onde for usar essa função seria ajustado para tal característica. Adendo: propositalmente deixei um erro na verificação no listarProdutos... lembre-se: as coisas tem que fazer sentido... Ao ler teria que vir a mente algo como: "Ham! como assim maior que 0". Oras! para "não haver produtos cadastrados, a quantidade tem que ser = 0". Lá está > 0 (se estiver maior, quer dizer que tem produtos!). Por aí vai.
  14. Só um detalhe sobre essa exibição dos valores na tela: O VisualG já insere automaticamente um espaço ANTES do número a ser impresso. Veja: Para C <- 0 Ate 9 Faca V[C] <- (C + 1) * 5 Escreva(V[C]) FimPara Escreval() Para C <- 0 Ate 9 Faca V[C] <- C Escreva(V[C]) FimPara "Pela lógica", os números sairiam todos colados, né? Mas na verdade saem assim: Ou seja: no teu código os números serão impressos com 2 e 3 espaços, respectivamente, entre si, pois terá um a mais à esquerda. (E não com 1 e 2, que foi o que colocou lá!). Caso queria imprimir sem esse espaço à esquerda, é possível utilizar um recurso de formatação. Veja: Para C <- 0 Ate 9 Faca V[C] <- (C + 1) * 5 Escreva(V[C]:1, " ") FimPara Escreval() Para C <- 0 Ate 9 Faca V[C] <- C Escreva(V[C]:1, " ") FimPara Assim, ficou "colado à esquerda" e ficou com apenas 1 e 2 espações respectivamente. E claro, se remover esses espaços após a vírgula, sairiam tudo colado. Como esses ":x" funciona? (Sendo x um número inteiro maior ou igual a zero, mas claro que terá uma limite...): basicamente ele vai definir "quantos espaços mínimos um número deve ocupar na tela, inserindo espaços à esquerda caso necessário". Pode ir fazendo testes com números diferentes e ir assimilando aos poucos. O detalhe é que, ao formatar com ":x", aquele tal "espaço automático à esquerda" é removido!! Aí pode ir brincado com as possibilidades.
  15. @Eli Almeidaa, teu código já está muito bom. Para efeito didático, aso queira treinar ou usar princípio no teu próprio código, segue um exemplo de possível refatoração no algoritmo. Vai um passo a passo inicial (que serve de modo genérico). [0] Escopo inicial Acho interessante deixar o enunciado no código... Facilita as consultas: algoritmo "Gerenciamento de Produtos v0.3" // Disciplina : // Professor : // Autor(a) : Eli Almeidaa // Data atual : 18/10/2023 // ENUNCIADO: //Você foi designado para criar um programa em portugol que ajude uma loja a //gerenciar seu estoque de produtos eletrônicos. A loja possui um catálogo de //produtos, cada um representado por um vetor de registro com as seguintes //informações: //* Nome do produto (string) //* Preço unitário (real) //* Quantidade em estoque (inteiro) //Sua tarefa é escrever um programa que realize as seguintes operações através //de funções: //* Cadastro de Produto: Crie uma função que permita ao usuário cadastrar um novo //produto, informando o nome, preço unitário e quantidade em estoque. Os dados //devem ser armazenados no vetor de produtos. //* Consulta de Estoque: Crie uma função que permita ao usuário consultar o //estoque de um produto específico, informando o nome do produto. A função deve //retornar a quantidade em estoque desse produto. //* Atualização de Estoque: Crie uma função que permita ao usuário atualizar o //estoque de um produto existente, informando o nome do produto e a quantidade //a ser adicionada ou subtraída do estoque. //Listagem de Produtos: Crie uma função que liste todos os produtos cadastrados, //exibindo o nome, preço unitário e quantidade em estoque de cada um. inicio fimAlgoritmo [1] DECLARAÇÃO DAS VARIÁVEIS E CONSTANTES GLOBAIS 1.1 as constantes deixar todo em MAIÚSCULO, para justamente diferenciar das variáveis; 1.2 em relação ao tipo, você está cadastrando produtos, e não lojas; 1.3 variáveis que são declaradas em assinaturas de métodos NÃO devem ser declaradas novamente como globais. Você aí está apenas "duplicando". (Sim! vai ficar uma variável global, e outra local para cada caso.); 1.4 alguns dessas variáveis deveriam ser declaradas dentro do métodos, e não como globais. De um modo simplificado poderia ficar assim: const QTD_MAX_PRODUTOS = 2 tipo t_Produto = registro nome : caractere preco : real estoque : inteiro fimRegistro var produtos : vetor [1..QTD_MAX_PRODUTOS] de t_Produto opcao, qtdProdutos : inteiro Só isso que é global. O restante seria variáveis locais. [2] Simplificação do menu Deixar o menu cru. Exemplo: inicio qtdProdutos <- 0 repita escrevaL("[1]- Cadastrar produto") escrevaL("[2]- Consultar produto") escrevaL("[3]- Atualizar estoque") escrevaL("[4]- Listar produtos") escrevaL("Escolha uma opcao") leia (opcao) escolha opcao caso 1 cadastrarProduto() caso 2 consultarEstoque() caso 3 atualizarEstoque() caso 4 listarProdutos() fimEscolha ate (opcao = 0) fimAlgoritmo Aí dentro de cada método constrói a sua lógica. Sugiro começar pela listagem, pois ela ajuda a ver se está cadastrando certo. Depois o cadastro (usando o listar como apoio). O código ficará muito mais limpo. [3] Listagem de Produtos Vai criando os métodos aos poucos. Sempre começando de algo mais simples e indo incrementando os detalhes depois. Exemplo: procedimento listarProdutos() var contador : inteiro inicio escrevaL("Produtos cadastrados :") para contador <- 1 ate qtdProdutos faca escrevaL("Nome : ", produtos[contador].nome) escrevaL("Preço : R$ ", produtos[contador].preco:1:2) escrevaL("Estoque : ", produtos[contador].estoque:1) escrevaL() fimPara fimProcedimento Adendo: o código não precisa ficar pronto de primeira, vai fazendo diversos testes até chegar numa versão que ache que ficou legal. Simples e direto. Aí, vai inserindo as validações. Exemplo: procedimento listarProdutos() var contador : inteiro inicio se (qtdProdutos <= 0) então escrevaL("Não há produtos cadastrados") senao escrevaL("Produtos cadastrados :") para contador <- 1 ate qtdProdutos faca escrevaL("Nome : ", produtos[contador].nome) escrevaL("Preço : R$ ", produtos[contador].preco:1:2) escrevaL("Estoque : ", produtos[contador].estoque:1) escrevaL() fimPara fimSe fimProcedimento [4] Cadastro de Produtos Segue outro exemplo de método: procedimento cadastrarProduto() var novoProduto : t_Produto inicio escrevaL("Informe o nome do produto") leia(novoProduto.nome) escrevaL("Informe o preço do produto") leia(novoProduto.preco) escrevaL("Informe o estoque do produto") leia(novoProduto.estoque) qtdProdutos <- qtdProdutos+1 produtos[qtdProdutos] <- novoProduto escrevaL("Produto cadastrado com sucesso") fimProcedimento Da mesma forma vai inserindo as validações aos poucos: funcao vetorCheio() : logico var retorno : logico inicio retorno <- VERDADEIRO se (qtdProdutos < QTD_MAX_PRODUTOS) então retorno <- FALSO fimSe retorne retorno fimFuncao funcao produtoExiste (nome:caractere) : logico var contador : inteiro existe : logico inicio existe <- FALSO para contador <- 1 ate qtdProdutos faca se (produtos[contador].nome = nome) então existe <- VERDADEIRO interrompa() fimSe fimPara retorne existe fimFuncao procedimento cadastrarProduto() var novoProduto : t_Produto inicio se (vetorCheio()) então escrevaL("Não há mais espaço no vetor para cadastro de novos produtos") senao escrevaL("Informe o nome do produto") leia(novoProduto.nome) se (produtoExiste(novoProduto.nome)) então escrevaL("Já existe um produto com o nome '", novoProduto.nome, "' no cadastro!") senao escrevaL("Informe o preço do produto") leia(novoProduto.preco) escrevaL("Informe o estoque do produto") leia(novoProduto.estoque) qtdProdutos <- qtdProdutos+1 produtos[qtdProdutos] <- novoProduto escrevaL("Produto cadastrado com sucesso") fimSe fimSe fimProcedimento [5] Alternativa para forma de validar Resumo: Textos dentro do métodos principais X textos dentro dos métodos de validação O código até aqui estaria com algo assim: algoritmo "Gerenciamento de Produtos v0.3" // Disciplina : // Professor : // Autor(a) : Eli Almeidaa // Data atual : 18/10/2023 // ENUNCIADO: ... const QTD_MAX_PRODUTOS = 2 tipo t_Produto = registro nome : caractere preco : real estoque : inteiro fimRegistro funcao existemProdutosCadastrados() : logico var retorno : logico inicio se (qtdProdutos > 0) então retorno <- VERDADEIRO senao retorno <- FALSO fimSe retorne retorno fimFuncao funcao vetorCheio() : logico var retorno : logico inicio retorno <- VERDADEIRO se (qtdProdutos < QTD_MAX_PRODUTOS) então retorno <- FALSO fimSe retorne retorno fimFuncao funcao produtoExiste (nome:caractere) : logico var contador : inteiro existe : logico inicio existe <- FALSO para contador <- 1 ate qtdProdutos faca se (produtos[contador].nome = nome) então existe <- VERDADEIRO interrompa() fimSe fimPara retorne existe fimFuncao procedimento cadastrarProduto() var novoProduto : t_Produto inicio se (vetorCheio()) então escrevaL("Não há mais espaço no vetor para cadastro de novos produtos") senao escrevaL("Informe o nome do produto") leia(novoProduto.nome) se (produtoExiste(novoProduto.nome)) então escrevaL("Já existe um produto com o nome '", novoProduto.nome, "' no cadastro!") senao escrevaL("Informe o preço do produto") leia(novoProduto.preco) escrevaL("Informe o estoque do produto") leia(novoProduto.estoque) qtdProdutos <- qtdProdutos+1 produtos[qtdProdutos] <- novoProduto escrevaL("Produto cadastrado com sucesso") fimSe fimSe fimProcedimento procedimento listarProdutos() var contador : inteiro inicio se (não existemProdutosCadastrados()) então escrevaL("Não há produtos cadastrados") senao escrevaL("Produtos cadastrados :") para contador <- 1 ate qtdProdutos faca escrevaL("Nome : ", produtos[contador].nome) escrevaL("Preço : R$ ", produtos[contador].preco:1:2) escrevaL("Estoque : ", produtos[contador].estoque:1) escrevaL() fimPara fimSe fimProcedimento var produtos : vetor [1..QTD_MAX_PRODUTOS] de t_Produto opcao, qtdProdutos : inteiro inicio qtdProdutos <- 0 repita escrevaL("[1]- Cadastrar produto") escrevaL("[2]- Consultar produto") escrevaL("[3]- Atualizar estoque") escrevaL("[4]- Listar produtos") escrevaL("Escolha uma opcao") leia (opcao) escolha opcao caso 1 cadastrarProduto() caso 2 consultarEstoque() caso 3 atualizarEstoque() caso 4 listarProdutos() fimEscolha ate (opcao = 0) fimAlgoritmo Ou seja: o método de cadastro que exibe a possível mensagem de erro. Mas poderia colocar o texto do "erro na validação" dentro do próprio método que valida, veja: funcao vetorCheio() : logico var retorno : logico inicio retorno <- FALSO se (qtdProdutos >= QTD_MAX_PRODUTOS) então escrevaL("Não há mais espaço no vetor para cadastro de novos produtos") retorno <- VERDADEIRO fimSe retorne retorno fimFuncao funcao produtoExiste (nome:caractere) : logico var contador : inteiro existe : logico inicio existe <- FALSO para contador <- 1 ate qtdProdutos faca se (produtos[contador].nome = nome) então escrevaL("Já existe um produto com o nome '", nome, "' no cadastro!") existe <- VERDADEIRO interrompa() fimSe fimPara retorne existe fimFuncao procedimento cadastrarProduto() var novoProduto : t_Produto inicio escrevaL("Informe o nome do produto") leia(novoProduto.nome) se ((não vetorCheio()) E (não produtoExiste(novoProduto.nome))) então escrevaL("Informe o preço do produto") leia(novoProduto.preco) escrevaL("Informe o estoque do produto") leia(novoProduto.estoque) qtdProdutos <- qtdProdutos+1 produtos[qtdProdutos] <- novoProduto escrevaL("Produto cadastrado com sucesso") fimSe fimProcedimento Dessa forma o texto fica centralizado em um lugar só, ou seja, se outros métodos principais precisaram utilizar de uma mesma validação, não será necessário escrever a mensagem de erro. É um duplo ganho. 1. não precisa reescrever a lógica de validação, basta invocar o método que deseja; 2. não precisa reescrever o texto de resposta, pois o texto está já no método que valida. Testando: Se já existir o nome: Se estiver cheio: Se estiver cheio e for um nome repetido: Veja que o programa pergunta o nome do produto mesmo se eventualmente estiver cheio... Aí vai tudo da forma que deseja que o programa se comporte, por exemplo, você pode querer que não pergunte o nome se já estiver cheio, aí precisaria ajustar o código para esse novo comportamento. Daí poderia fazer o mesmo com o lista, ou seja, o texto: escrevaL("Não há produtos cadastrados") que está dentro do listarProdutos() e passaria então a ficar no existemProdutosCadastrados(). Após ajustaria o listarProdutos() para essa nova mudança (ficando análogo ao cadastrarProduto()). O importante que a estrutura do código fique homogênea, ou seja, fica estranho uma método ter um padrão, e outro ter um diferente. Procurar deixar uniforme.

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×
×
  • Criar novo...