Simon Viegas
-
Posts
3.931 -
Cadastrado em
Tipo de conteúdo
Artigos
Selos
Fabricantes
Livros
Cursos
Análises
Fórum
posts postados por Simon Viegas
-
-
13 horas atrás, devair1010 disse:
funcao sub_rotina(tam_vet : inteiro):inteiro Var A,L : inteiro Inicio Para L de 1 ate 9 Faca Para A de 1 ate 10 - L Faca Se Vet[A ] > Vet[A + 1] então Aux := Vet[A ] Vet[A ] := Vet[A + 1] Vet[A + 1] := aux FimSe FimPara FimPara retorne tam_vet Fimfuncao
Está recebendo o parâmetro, mas não está usando na ordenação... Poderia ficar com algo assim:
Para L de 1 ate tam_vet Faca Para A de 1 ate tam_vet - L Faca
Daí o retorno também não seria necessário, pois está retornando o próprio valor original que foi recebido. Se não me engano isso seria uma Tautologia. Portanto, usaria um procedimento (que não tem retorno na próprio método), em detrimento de usar uma função (que é basicamente um procedimento que tem o tal retorno).
PS: em linguagens mais modernas/comuns, não existe diferenciação entre procedimento e função, tudo é função... daí, as funções podem ou não retornar algo... quando não precisa retornar, comumente é definido com o "retorno void" (que significa vazio), ou seja, se o VisualG tivesse esse conceito, um procedimento seria algo assim:
funcao xpto () : vazio inicio fimFuncao
Alguns pontos:
19 horas atrás, Gustavo Alves7 disse:L, A, Aux: Inteiro
Por que especificamente "L" e "A"? Tem alguma correlação com algo?Convencionalmente utilizam-se "i" e "j" como variáveis auxiliares para as iterações do para.
i, j, aux : inteiro
Como sugerível acima, as variáveis e comando também são comumentes iniciadas em minúsculo. Dá uma pesquisada sobre camelCase... (Obs.: isso não é obrigatório, estaria relacionado mais a uma tentativa de seguir um suposto padrão geral.
Exemplo de código sem sub-rotina:
algoritmo "EXE4SUBROTINAS" //Para demonstrar o uso de sub-rotina com passagem de parâmetro, considere a //leitura de 10 valores em um vetor e os coloque em ordem crescente. A //ordenação deve ser executada por uma sub-rotina apropriada para este fim. var vet : vetor [1..10] de inteiro i, j, aux : inteiro inicio para i de 1 ate 10 faca escreva ("Digite um numero: ") leia(vet[i]:3) fimPara escreva ("Vetor original :") para i <- 1 ate 10 Faca escreva (vet[i]) fimPara escrevaL("") para i de 1 ate 9 Faca para j de 1 ate 10-i faca se (vet[j] > vet[j+1]) então aux <- vet[j] vet[j] <- vet[j+1] vet[j+1] <- aux fimSe fimPara fimPara escreva ("Vetor ordenado :") para i <- 1 ate 10 faca escreva (vet[i]:3) fimPara fimAlgoritmo
Para facilita os testes, pode deixar essa opção marcada:
Ai o próprio VisualG preenche com valores aleatório. Resultado ao pressionar F9:
19 horas atrás, Gustavo Alves7 disse:Para demonstrar o uso de sub-rotina com passagem de parâmetro [...]
Como já citado, por uma limitação técnica (o criador/desenvolvedor) simplesmente não implementou o recurso que possibilite passar vetores por parâmetro em procedimentos ou funções. É isso! O Pascal, "pai do VisualG", permite! Quem sabe vem numa próxima versão?
Daí... meio que o enunciado fica vago... Pois o vetor, necessariamente, terá que ser "passado" via variável global... e o tamanho do vetor também já é conhecido e fixo... já que está no próprio enunciado:
19 horas atrás, Gustavo Alves7 disse:considere a leitura de 10 valores em um vetor
19 horas atrás, Gustavo Alves7 disse:A ordenação deve ser executada por uma sub-rotina apropriada para este fim
O código poderia ficar com algo assim:
O esqueleto do procedimento:
procedimento bubbleSort () inicio fimProcedimento
https://pt.wikipedia.org/wiki/Bubble_sort
Aí só joga o conteúdo dentro:
para i de 1 ate 9 Faca para j de 1 ate 10-i faca se (vet[j] > vet[j+1]) então aux <- vet[j] vet[j] <- vet[j+1] vet[j+1] <- aux fimSe fimPara fimPara
ADENDO IMPORTANTE:
Como boa prática, é interessante que "tudo que método use, ou venha por parâmetro, ou seja declarado dentro do método", ou seja, o vetor e o tamanho do vetor deveriam* vir por parâmetro (o primeiro o VisualG não permite, o segundo já foi proposto que é fixo), e as variáveis utilizadas no laços de repetições, declaradas dentro do método (criação de variáveis locais, que se separam das variáveis locais). Veja:
procedimento bubbleSort () var i, j, aux : inteiro inicio para i de 1 ate 9 Faca para j de 1 ate 10-i faca se (vet[j] > vet[j+1]) então aux <- vet[j] vet[j] <- vet[j+1] vet[j+1] <- aux fimSe fimPara fimPara fimProcedimento
Daí só invocar o método onde precisa:
... escreva (vet[i]:3) fimPara escrevaL("") bubbleSort() escreva ("Vetor ordenado :") para i <- 1 ate 10 faca ...
Olha como é interessante, uma sub-rotina seria basicamente um bloco de comandos em que se deu um nome... aí só invocar! Na prática, o VisualG vai "pular" para o trecho de código e ir executando linha a linha da mesma forma que se tivesse no corpo principal do código e depois volta para próxima linha depois de onde foi invocado. Como se fosse um "subprograma". O programa principal fica aguardando a sub-rotina terminar.
Código completo:
Spoileralgoritmo "EXE4SUBROTINAS" //Para demonstrar o uso de sub-rotina com passagem de parâmetro, considere a //leitura de 10 valores em um vetor e os coloque em ordem crescente. A //ordenação deve ser executada por uma sub-rotina apropriada para este fim. procedimento bubbleSort () var i, j, aux : inteiro inicio para i de 1 ate 9 Faca para j de 1 ate 10-i faca se (vet[j] > vet[j+1]) então aux <- vet[j] vet[j] <- vet[j+1] vet[j+1] <- aux fimSe fimPara fimPara fimProcedimento var vet : vetor [1..10] de inteiro i, j, aux : inteiro inicio para i de 1 ate 10 faca escreva("Digite um numero: ") leia(vet[i]) fimPara escreva ("Vetor original :") para i <- 1 ate 10 Faca escreva (vet[i]:3) fimPara escrevaL("") bubbleSort() escreva ("Vetor ordenado :") para i <- 1 ate 10 Faca escreva (vet[i]:3) fimPara fimAlgoritmo
Aí, como parâmetros são necessário, poderia seguir a sugestão do @devair1010, ficaria algo assim:
procedimento bubbleSort (tam : inteiro) var i, j, aux : inteiro inicio para i de 1 ate tam-1 Faca para j de 1 ate tam-i faca se (vet[j] > vet[j+1]) então aux <- vet[j] vet[j] <- vet[j+1] vet[j+1] <- aux fimSe fimPara fimPara fimProcedimento
Chama o método passando o parâmetro necessário.
... escrevaL("") bubbleSort(10) escreva ("Vetor ordenado :") ...
Ou, ainda aprimorar o Bubble Sort(), criando um método específico para efetuar as trocas de posições:
algoritmo "EXE4SUBROTINAS" //Para demonstrar o uso de sub-rotina com passagem de parâmetro, considere a //leitura de 10 valores em um vetor e os coloque em ordem crescente. A //ordenação deve ser executada por uma sub-rotina apropriada para este fim. procedimento troca(var a, b : inteiro) var aux : inteiro inicio aux <- a a <- b b <- aux fimProcedimento procedimento bubbleSort () var i, j : inteiro inicio para i de 1 ate 10-1 Faca para j de 1 ate 10-i faca se (vet[j] > vet[j+1]) então troca(vet[j], vet[j+1]) fimSe fimPara fimPara fimProcedimento var vet : vetor [1..10] de inteiro i, j, aux : inteiro inicio para i de 1 ate 10 faca escreva("Digite um numero: ") leia(vet[i]) fimPara escreva ("Vetor original :") para i <- 1 ate 10 Faca escreva (vet[i]:3) fimPara escrevaL("") bubbleSort() escreva ("Vetor ordenado :") para i <- 1 ate 10 Faca escreva (vet[i]:3) fimPara fimAlgoritmo
Ou seja: o procedimento troca() já satisfaria a exigência do enunciado ("uso de sub-rotina com passagem de parâmetro"). Mas tanto faz também deixar o método de ordenação também recebendo o parâmetro com o tamanho do vetor.
Ah! se o VisualG aceitasse vetores por parâmetro, a assinatura seria algo assim:
procedimento bubbleSort (var vet:vetor)
Ou:
procedimento bubbleSort (var vet:vetor; tam:inteiro)
Lembrando que isso NÃO FUNCIONA... pois ainda não foi implementando no VisualG. Já no Pascal, sim!... (não exatamente assim, mas funciona
)
PS: esse var determina que seria uma passagem de parâmetro do referência, ou seja, a variável local do método aponta diretamente para própria variável da qual foi passado o parâmetro, assim, tudo que for alterado dentro do método, será refletido na variável original... Funciona como um "ponteiro de memória". Já sem o var, o VisualG apenas "copia" o valor original e joga na variável local. Ao sair, a variável original fica intacta.
POSSÍVEL DÚVIDAS:
Oxente, por que declarou duas vezes as variáveis i e j? E pior, por que o VisualG não acusou que a variável foi "declarada mais de uma vez". Vide exemplo:
Resposta: as variáveis i e j foram declaradas "novamente" pois eventualmente o escopo do método precisa dessas variáveis, e como foi exposto no "ADENDO IMPORTANTE" mais acima, o objetivo é "isolar" o método do programa principal, ou seja, mesmo que seja modificado o laço de repetição no programa principal, o método não será comprometido, pois "tudo dentro do método ou veio de fora ou foi criado dentro do método"...
Por fim, foi utilizado também as mesmas letras, pois o VisualG permite. Poderia ser letras diferentes. Só se atente que são variáveis distintas! Tem a mesma nomenclatura, mas são de escopos diferentes. Veja:
Cada par de variável não tem nada a ver com o outro. Se não declarasse as variáveis locais, a sub-rotina iria utilizar a variáveis globais...
A magia vem aí... ao implementar uma método, você não precisa se preocupar se já existe uma variável com a mesma nomenclatura fora, nem muito menos vai se preocupar se está alterando um valor que não deveria... Por isso a importância do "isolamento". Isso vai ficar mais claro e medida que for implementando programas maiores... imagine a trabalheira que dá ficar "cuidado de cada variável".
-
1
-
-
@Luigi Milleo, além da imagem do erro, numas próximas ocasiões, poste também o código fonte (o texto). Assim facilita os teste e ajudar indexar a postagem.
-
1
-
-
13 horas atrás, jooao2607 disse:
boa noite, estou com essa duvida aqui se existe alguma regra ou algo do tipo onde eu não possa usar o <FOR>, ou pode usar em qualquer circunstancia
@jooao2607, o que pode ocorrer é que uma estrutura de repetição (como o For, While, Do While, For Each etc) possa ser mais prática ou adequada que a outra para um caso, mas meio que não existe uma regra específica obrigue utilizar uma coisa ou outra. Vai do contexto. Cada estrutura pode funcionar melhor ou pior que a outra. Ou pode também existir "padrões de implementações", ou seja, uma forma de fazer que seria mais comum no dia a dia dos programadores em geral...
Teria algum exemplo para contextualizar melhor a tua dúvida?
-
1
-
1
-
-
Em 03/05/2024 às 17:25, Ansi C disse:
repita contador <- contador + 1 Escreval(contador) Ate (contador = 10)
Só um detalhe... Para garantir o melhor funcionamento, utilizar ">=". Por que se der alguma zica e passar do 10, praticamente* vai entrar num loop infinito
.
* o tipo numérico inteiro tem um limite (pra lá de uns 2 bilhões positivos, pelo menos num x64), daí pularia para negativo (mais uns pra lá de 2 bi), até voltar para o positivo novamente podendo ou não repetir a zica.
PS: outra forma seria começar do 1 e ajustar o limite:
algoritmo "Conte Ate 10 (inclusive)" var contador : inteiro inicio contador <- 1 repita escreval(contador) contador <- contador + 1 ate (contador > 10) fimAlgoritmo
Como é uma contagem, o para seria ainda mais harmonioso:
algoritmo "Conte Ate 10 (inclusive)" var contador : inteiro inicio para contador de 1 ate 10 faca escreval(contador) fimPara fimAlgoritmo
Obviamente, se o tópico de estudo for o repita, tem que ser com o repita.
-
2
-
-
Só analisando alguns pontos...
Um detalhezinho para o primeiro código:
Em 14/04/2024 às 01:41, Eli Almeida disse:reiniciarVelha() se simbolo = "x" então simbolo <- "o" senao se simbolo = "o" então simbolo <- "x" fimse fimse
Oras! Essa "troca" já existia no código:
Em 14/04/2024 às 01:41, Eli Almeida disse:procedimento trocarJogador () inicio se simbolo = "x" então simbolo <- "o" senao simbolo <- "x" fimSe fimProcedimento
Seria só chamar a função:
reiniciarVelha() trocarJogador()
...no novo código o problema da substituição já foi resolvida, que seria "salvando o jogador que vai começar".
Para o novo código, temos um probleminha de conceito. Se a função chama-se "mostrar", nela não* deveria mexer em nada nos dados.... Só remover o se.
Errado*
Em 15/04/2024 às 01:36, Eli Almeida disse:procedimento mostrarVelha () var linha, coluna, contador : inteiro inicio contador <- 1 para linha <- 1 ate 3 faca para coluna <- 1 ate 3 faca se (tabela[linha,coluna] <> "x") e (tabela[linha,coluna]<> "o") então tabela[linha,coluna] <- numpcarac(contador) fimse escreva(tabela[linha,coluna]:3) contador <- contador+1 fimPara escreval() fimPara fimProcedimento
Correto:
procedimento mostrarVelha () var linha, coluna : inteiro inicio para linha <- 1 ate 3 faca para coluna <- 1 ate 3 faca escreva (tabela[linha,coluna]:3) fimPara escreval() fimPara fimProcedimento
Veja que no código "errado", para cada vez que mostrar a velha, estará reescrevendo a tabela redundantemente. (Onde já tem o número, vai ter o mesmo número novamente...)
A mesma regra vale para o reiniciarVelha().
Em 15/04/2024 às 01:36, Eli Almeida disse:procedimento reiniciarVelha() var contador : inteiro inicio contador <- 1 para linha <- 1 ate 3 faca para coluna <- 1 ate 3 faca tabela[linha,coluna] <- numpcarac(contador) escreva(tabela[linha,coluna]:3) contador <- contador+1 fimpara escreval() fimpara se c = "x" então simbolo <- "o" c <- simbolo senao se c = "o" então simbolo <- "x" c <- simbolo fimse fimse fimProcedimento
Já existe uma função com o papel de mostrar, correto?... Deixa então o ela executar. Só remover o se lá dentro do para.
procedimento reiniciarVelha () var contador : inteiro inicio contador <- 1 para linha <- 1 ate 3 faca para coluna <- 1 ate 3 faca tabela[linha,coluna] <- numpcarac(contador) contador <- contador+1 fimpara fimpara se c = "x" então simbolo <- "o" c <- simbolo senao se c = "o" então simbolo <- "x" c <- simbolo fimse fimse fimProcedimento
Cada um no seu quadrado
.
**Como esperado, daí vai precisar chamar as duas funções para o código funcionar corretamente**
Por falar em papeis... poderia retirar esse "troca da vez" de dentro do reiniciarVelha(), pois seria também uma função separada. Poderia criar algo como "definirQuemJoga()", onde na primeira vez seta para o "x", e depois seguiria com essa lógica de alternar o jogador. No código, chamaria logo após o comando enquanto, antes do repita. (Não testei, mas acho que lá mesmo.)
-
1
-
-
@Samuel Fortes Brasil, o código está até bem arrumado, mas tem uns probleminhas que precisam se verificados. Poderia postar o enunciado completo da questão para sermos mais precisos?
Para adiantar, alguns pontos:
Procure deixar o código o mais semântico possível, ou seja, com nomenclaturas de variáveis e estruturas fazendo o maior sentido possível... Veja:
Em 29/04/2024 às 16:58, Samuel Fortes Brasil disse:Inicio Escreval("-----------------------------------") Escreva("Quantos alunos a turma possui: ") Leia(turma)
Você pergunta "quantos alunos", mas o nome da variável está chamando-se "turma". Que tal chamar de "quantidadeDeAlunos"? Percebe que só de ler o nome da variável você já tem uma noção de mais ou menos para que ela vai servir? Para simplificar, é também comum abreviar. Ex.: qtdAlunos. Se existissem outros de tipos de quantidade, poderia ser ainda mais explicativo. Ex: qtdAlunosTurma, qtdAlunosColegio etc. Mas nesse caso, não precisa.
Outro ponto:
Em 29/04/2024 às 16:58, Samuel Fortes Brasil disse:caso 2 Escreva("Qual é o nome do(a)Aluno(a): ") Leia(N1) Escreva("Nota: ") Leia(Nota) Escreva("Qual é o nome do(a)Aluno(a): ") Leia(N2) Escreva("Nota: ") Leia(Nota)
Observe que N1 ficou ambíguo.. não se sabe se seria para "Nota" ou "Nome". Pior: se N1 (e afins) são para nomes, porque está estruturada para receber números lá na declaração de variáveis?
Em 29/04/2024 às 16:58, Samuel Fortes Brasil disse:Var turma:Inteiro N1,N2,N3,N4,N5:Inteiro
Ou seja: seguir esse princípio de "manter uma boa semântica", já evitaria isso. Poderia ficar assim:
algoritmo "Cadastro de Notas de Alunos" var qtdAlunos : inteiro nome1, nome2, nome3, nome4, nome5 : caractere
Tipo, na hora que estivesse escrevendo, já veria que "que seria estranho associar um nome ao tipo numérico", saca? A coisa não estaria semântica.
Observe também que está utilizando a mesma nota para cada um dos alunos, ou seja, a cada nova leitura, estará perdendo o dado anterior, pois simplesmente será substituído. Poderia ter uma nota para cada aluno... assim como tem um nome para cada um.
Até aqui poderia ser algo como:
algoritmo "Cadastro de Notas de Alunos" var qtdAlunos : inteiro nome1, nome2, nome3, nome4, nome5 : caractere nota1, nota2, nota3, nota4, nota5 : real inicio escrevaL("-----------------------------------") escreva ("Quantos alunos a turma possui: ") leia(qtdAlunos) escrevaL("-----------------------------------") enquanto (qtdAlunos > 5) faca escrevaL("Não é possível criar registro de uma turma") escrevaL("com mais de 5 alunos. Por favor informe um número menor!") escreva ("Informe um novo valor: ") leia(qtdAlunos) escrevaL("-----------------------------------") fimEnquanto fimAlgoritmo
Entrando na leitura dos dados:
algoritmo "Cadastro de Notas de Alunos" var qtdAlunos : inteiro nome1, nome2, nome3, nome4, nome5 : caractere nota1, nota2, nota3, nota4, nota5 : real cont : inteiro inicio escrevaL("-----------------------------------") escreva ("Quantos alunos a turma possui: ") leia(qtdAlunos) escrevaL("-----------------------------------") enquanto (qtdAlunos > 5) faca escrevaL("Não é possível criar registro de uma turma") escrevaL("com mais de 5 alunos. Por favor informe um número menor!") escreva ("Informe um novo valor: ") leia(qtdAlunos) escrevaL("-----------------------------------") fimEnquanto escolha (qtdAlunos) caso 1 escreva ("Qual é o nome do(a)Aluno(a): ") leia(nome1) escreva ("Nota: ") leia(nota1) caso 2 escreva ("Qual é o nome do(a)Aluno(a): ") leia(nome1) escreva ("Nota: ") leia(nota1) escreva ("Qual é o nome do(a)Aluno(a): ") leia(nome2) escreva ("Nota: ") leia(nota2) caso 3 escreva ("Qual é o nome do(a)Aluno(a): ") leia(nome1) escreva ("Nota: ") leia(nota1) escreva ("Qual é o nome do(a)Aluno(a): ") leia(nome2) escreva ("Nota: ") leia(nota2) escreva ("Qual é o nome do(a)Aluno(a): ") leia(nome3) escreva ("Nota: ") leia(nota3) caso 4 escreva ("Qual é o nome do(a)Aluno(a): ") leia(nome1) escreva ("Nota: ") leia(nota1) escreva ("Qual é o nome do(a)Aluno(a): ") leia(nome2) escreva ("Nota: ") leia(nota2) escreva ("Qual é o nome do(a)Aluno(a): ") leia(nome3) escreva ("Nota: ") leia(nota3) escreva ("Qual é o nome do(a)Aluno(a): ") leia(nome4) escreva ("Nota: ") leia(nota4) caso 5 escreva ("Qual é o nome do(a)Aluno(a): ") leia(nome1) escreva ("Nota: ") leia(nota1) escreva ("Qual é o nome do(a)Aluno(a): ") leia(nome2) escreva ("Nota: ") leia(nota2) escreva ("Qual é o nome do(a)Aluno(a): ") leia(nome3) escreva ("Nota: ") leia(nota3) escreva ("Qual é o nome do(a)Aluno(a): ") leia(nome4) escreva ("Nota: ") leia(nota4) escreva ("Qual é o nome do(a)Aluno(a): ") leia(nome5) escreva ("Nota: ") leia(nota5) fimEscolha //aqui entraria o processamento dos dados e depois exibição dos resultados... mas aí vai depender do enunciado fimAlgoritmo
Daí, a lógica utilizada para o processamento e exibição do resultado, vai depender do que está no enunciado do problema. Se for algo como "exibir a maior nota e o nome do respectivo aluno", já adianto que não daria muito certo, pois iria dar uma trabalheira absurda ir comparando as nota por nota... teria que pensar em outra lógica... e sempre se baseando no enunciado do problema.
Se você já estiver com uma solução, por favor, posta o enunciado completo e código aqui para analisarmos... Caso não, posta o enunciado e o que já conseguiu fazer.
No aguardo.
-
1
-
-
Em 13/04/2024 às 14:44, devair1010 disse:
mas fiz uns testes de mesa no visualG 3,0,6,5 , e essa estrutura funcionou
Pois é! Entendo que basicamente seria uma falha de programação do VisualG. De um modo geral não recomendaria o uso dessa estrutura (usaria se ou se/senao), pois foge do que seria o padrão, tanto para o Pascal (pai do VisualG), tanto para maioria das outras linguagens. (Apesar de fazer sentido, ou seja, não seria uma estrutura documentada, mas alguém teve a brilhante ideia de usar... e funcionou* kkkkkkkkkk).
Eu não encontrei um documentação oficial, e os documentos que tem são bem simplificados.
Mas só para citar que existem claros problemas, vejam:
Oras! desde quando 10.5 está entre 0 e 10?
O que empiricamente eu entendo até aqui:
- escolha só aceita variáveis do tipo inteiro ou caractere. Ela não foi programada para aceitar números reais. (Acaba "rodando", mas não deveria.);
- os itens dos casos são, quando necessários, separados por ",". Ela não foi programada para aceitar faixa de valores, como no tal contexto de "x ate y". (Acaba "rodando", mas não deveria.);
-
Opa! Vou tentar detalhar alguns pontos.
Em 11/04/2024 às 17:50, Sants_021 disse:Estou tentando a horas achar o erro, mas parece q e impossível.
Testei nas versões 2.5.1920, 3.0.6.5 e 3.0.7.0 do VisualG, e todos apresentaram o mesmo erro.
Segue tela de teste:
Tela com resultado da execução mostrando o resultado final, mas com uma tela de aviso sobrepondo a tela anterior, indicando que encontrou o erro "FIMPARA sem PARA correspondente."
Ou seja: exatamente o sugerido por @devair1010:
Em 11/04/2024 às 22:30, devair1010 disse:Escreval("Auxilio Alimentação:",aux_aliment," Salario Final:",sal_final) fimpara // <---------- essa linha Aqui, pois não tem o outro comando, o "para" Fimalgoritmo
Para resolver esse erro, antes um dica: sempre que for programando, vá pressionando Ctrl+G no VisualG para efetuar a indentação automática (o ideal é meio que já programar deixando indentando também). Com isso, ficará bem visível que tinha "algo a mais". Veja:
Print de tela indicando menu, do VisualG, onde consta a item "Indentação Ctrl+G"
Print de tela destacando o comando fimpara na linha 52
Ou seja: o fimpara está recuado "um dente" para esquerda, ao procurar nas linhas de cima (na mesma coluna), não encontra o respectivo comando para, logo, precisa corrigir... que seria simplesmente remover a linha ou eventualmente inserir o tal para, se fosse o caso.
RESUMINDO: provavelmente, OU esqueceu de inserir o trecho o para no código:
Em 21/11/2023 às 23:49, ElliePJ disse:para i <-1 ate 400 faca
OU esqueceu de remover o fimPara quando decidiu remover o comando supracitado...
Outro ponto importante que tinha passado... Essa estrutura escolha abaixo não existe (pelo menos até onde me lembro e pesquisei):
Em 11/04/2024 às 17:50, Sants_021 disse:escolha (sal_inicial)
Caso 0 ate 780
aux_aliment <- sal_inicial * 0.25
Caso 781 ate 1200
aux_aliment <- sal_inicial * 0.20
Caso 1201 ate 9999999
aux_aliment <- sal_inicial * 0.15
fimescolhaOu seja: o escolha não funciona para "faixas de valores", mas sim apenas para "lista de valores" (separados por ",", caso exista mais de um). Não tem isso de "x até y" para os casos. É assim no Pascal (pai do VisualG), seria assim no VisualG. Tá rodando, mas não necessário está executando corretamente. O código estaria apresentando problemas no VisualG... Tenho 94.7% de certeza disso. Favor me corrijam se estiver enganado... Em outras palavras, poderia utilizar a estrutura se e/ou se/senao. Veja:
algoritmo "Folha" var codigo, horas_trab :inteiro turno, categoria :caractere sal_minimo, valor_hora, sal_inicial, aux_aliment, sal_final :real inicio escrevaL("Digite o codigo do funcionario:") leia(codigo) escrevaL("Digite o numero de horas trabalhadas no mês:") leia(horas_trab) escrevaL("Digite o turno de trabalho (M-Matutino, V-Vespertino, N-Noturno)") leia(turno) escrevaL("Informe a categoria do (G-Gerente, F-Funcionario)") leia(categoria) escrevaL("Digite o valor do salario minimo:") leia(sal_minimo) se (categoria = "G") e (turno = "N")então valor_hora <- sal_minimo * 0.06 fimSe se (categoria = "G") e (turno = "M")então valor_hora <- sal_minimo * 0.04 fimSe se (categoria = "G") e (turno = "V")então valor_hora <- sal_minimo * 0.04 fimSe se (categoria = "F") e (turno = "N")então valor_hora <- sal_minimo * 0.02 fimSe se (categoria = "F") e (turno = "M")então valor_hora <- sal_minimo * 0.01 fimSe se (categoria = "F") e (turno = "V")então valor_hora <- sal_minimo * 0.01 fimSe sal_inicial <- horas_trab * valor_hora se (sal_inicial >= 0) E (sal_inicial <= 800) então aux_aliment <- sal_inicial * 0.25 fimSe se (sal_inicial > 800) E (sal_inicial <= 1200) então aux_aliment <- sal_inicial * 0.20 fimSe se (sal_inicial > 1200) então aux_aliment <- sal_inicial * 0.15 fimSe sal_final <- sal_inicial + aux_aliment escrevaL("Codigo: ", codigo:1, " Horas Trabalhadas: ", horas_trab:1) escrevaL("Valor da Hora Trabalhada: ", valor_hora:1:2, " Salario Inicial: ", sal_inicial:1:2) escrevaL("Auxilio Alimentação: ", aux_aliment:1:2, " Salario Final: ", sal_final:1:2) fimAlgoritmo
Pontos para verificar posteriormente:
- a verificação de turnos "M" e "V" podem ser agrupados em uma verificação só, do jeito que está, está "duplicando código";
- como existem condições mutuamente excludentes entre si nessas sequências de se, poderia utilizar estruturas com conjuntos de se/senão, em vez de um monte de se isolados.
No aguardo.
-
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:
Em 27/11/2023 às 16:27, Eli Almeida disse:para linha <- 1 ate 4 faca escreva(" ",bimestre[linha]:15) fimpara
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
2 horas atrás, Eli Almeida disse:Agora gostaria de saber como faço para colocar as linhas e deixar os bimestres e as matérias junto com as notas dentro do retângulo.
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".
2 horas atrás, Eli Almeida disse:Nessa parte aqui : Escreva(bimestre[linha]:12), ele conta a quantidade de caracteres e deixa somente um espaço à esquerda ?
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:
2 minutos atrás, Simon Viegas disse:escreva (notasBimestres[linha, coluna]:12:2)
idem: vai fazendo testes até compreender.-
2
-
1
-
-
Em 22/11/2023 às 21:18, ElliePJ disse:
Acredito que estou errando na hora parte da estrutura, com o se e então, ou até mesmo na parte de escolha. Não sei se é realmente isso mas acredito que seja. Quando tentei, os cálculos chegavam apenas a zero.
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:
Em 22/11/2023 às 14:28, Simon Viegas disse:[...] o turno vem antes da categoria.
Exemplo informando errado:
Aí vai sair zerado mesmo...
-
1
-
-
Em 23/11/2023 às 02:46, HenriqueArisi disse:
sei q nem sempre o que ele acusa é o que esta incorreto!
Sim..., mas comece pelo que foi informado.
Em 23/11/2023 às 02:46, HenriqueArisi disse:
Está dizendo que não foi encontrada a posição 0 do vetor nome.
Em 23/11/2023 às 02:46, HenriqueArisi disse:nome: vetor[1..50] de caractere
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
-
14 horas atrás, ElliePJ disse:
Cheguei até aí mas tem algo dando errado e não consigo mais avançar.
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:
15 horas atrás, ElliePJ disse:Escreval("Digite o codigo do funcionario:") Leia(codigo) Escreval("Digite o numero de horas trabalhadas no mês:") Leia(horas_trab) Escreval("Informe a categoria do (G-Gerente, F-Funcionario)") Leia(categoria) Escreval("Digite o turno de trabalho (M-Matutino, V-Vespertino, N-Noturno)") Leia(turno) Escreval("Digite o valor do salario minimo:") Leia(sal_minimo)Sugiro deixar na ordem do enunciado, ou seja, o turno vem antes da categoria.
Adendo 2:
15 horas atrás, ElliePJ disse:outrocaso escreval ("Opção Invalida")Essa validação não faz parte do enunciado, basta remover.
-
1
-
-
22 horas atrás, Eli Almeida disse:
Porém existe um problema que não sei como solucionar, no caso, quando executa o código e o programa escolhe os nomes aleatoriamente, ele acaba escolhendo nomes repetidos, como nesse caso, ele repetiu Gabriel duas vezes.
É 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.
-
1
-
-
Show! Só um detalhe: ao informar um nome de produto inexistente, o programa "não faz nada".
Poderia dar uma arrumada nisso.
-
19 horas atrás, Eli Almeidaa disse:
Fazer essa questão usando registro não seria mais adequado?
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.
19 horas atrás, Eli Almeidaa disse:Por quê utilizar vetor ao invés de registro?
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.
-
1
-
-
No caso:
System.out.println("Seu sistema está em " + idioma);
Seria equivalente a:
System.out.print("Seu sistema está em "); System.out.println(idioma);
-
1
-
-
Em 09/11/2023 às 15:37, Eli Almeidaa disse:
Não consegui pensar em uma lógica para usar os valores verdadeiro e falso, como você já vinha fazendo para retornar um valor lógico para essa função.
Do que entendi, você está usando os valores lógicos.
Em 09/11/2023 às 15:37, Eli Almeidaa disse:se (produtoCadastrado(novoProduto.nome)) então fimse
O se está utilizando o valor retornado pela função.
Em 09/11/2023 às 15:37, Eli Almeidaa disse:Fiz assim, não sei se está correto:
Pra mim ficou correto, sim. Tá muito bom!
Para exemplificar uma nova possível simplificação:
DE:
Em 09/11/2023 às 15:37, Eli Almeidaa disse: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 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
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.
-
1
-
1
-
-
@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:
1 hora atrás, dmoret disse:senao se categoria = "2" então
- 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:
1 hora atrás, JoãoPe230 disse:Aqui "Escolha" é melhor mesmo, funciona com "Se", mas fica mais otimazado e correto com "Escolha", tudo que for com algarismo e não tiver ">, < e etc" "escolha" é melhor
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).
-
3
-
1
-
@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:
Em 27/10/2023 às 16:49, Eli Almeidaa disse:retorno <- falso
Para:
retorno <- FALSO
FALSO e VERDADEIRO são constantes...
De:
Em 27/10/2023 às 16:49, Eli Almeidaa disse:se vetorCheio = falso então
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:
Em 27/10/2023 às 16:49, Eli Almeidaa disse:se vetorCheio = falso então repita produtoJaExiste <- falso escrevaL("Informe o nome do produto") leia(novoProduto.nome) se produtoExiste(novoProduto.nome) = falso 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") senao ProdutoJaExiste <- verdadeiro fimSe ate (ProdutoJaExiste = falso) fimSe
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
Em 27/10/2023 às 16:49, Eli Almeidaa disse:funcao existemProdutosCadastrados() : logico
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 fimFuncaoJá 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:
Em 27/10/2023 às 16:49, Eli Almeidaa disse:se existemProdutosCadastrados = verdadeiro então escrevaL("Produtos cadastrados :")
Para:
se (não vetorVazio()) então escrevaL("Produtos cadastrados :")
De:
Em 27/10/2023 às 16:49, Eli Almeidaa disse:procedimento consultarEstoque () var novoProduto : t_Produto r:inteiro inicio se existemProdutosCadastrados = verdadeiro então escreval("Informe o nome do produto que gostaria de consultar o estoque") leia(novoProduto.nome) se buscaPosicaoProduto(novoProduto.nome)> 0 então escreval(" O estoque de ", novoProduto.nome, " é ", produtos[buscaPosicaoProduto(novoProduto.nome)].estoque:1) fimSe fimse fimProcedimento
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".
-
2
-
1
-
-
Em 23/10/2023 às 20:53, como ta a mente do palhaço disse:
algoritmo "Q89 procedimento" var vezes, repet, repet1, bor :inteiro bor1, n, c : caractere inicio
O comando inicio, relacionado ao programa principal, deve ficar após as funções e procedimento.
Aproveitando a postagem:
Em 15/04/2023 às 10:07, Fran.DevCoder disse:algoritmo "Exercício 89" //... var contador : inteiro msg : caractere
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:
Em 15/04/2023 às 10:07, Fran.DevCoder disse://Ex: Uma chamada válida seria Gerador("Portugol Studio",3,2)Mas no código está utilizando a variável global msg.
Em 15/04/2023 às 10:07, Fran.DevCoder disse:inicio gerador(msg, 3, 2) fimAlgoritmo
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:
Em 15/04/2023 às 10:07, Fran.DevCoder disse:procedimento gerador(msg:caractere; repeticao, borda_tipo:inteiro) inicio borda(borda_tipo) para contador de 1 ate repeticao faca escreval("Portugol Studio") fimPara borda(borda_tipo) fimProcedimento
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
-
Em 21/10/2023 às 15:14, Eli Almeidaa disse:
O código da forma que você está fazendo aí, como criando função existemProdutosCadastrados, função vetorCheio e função produtoExiste, seria a forma mais correta de fazer essa questão?
Assim..., não seria "a" forma mais correta, seria apenas "umas" sugestões. Seria tentar seguir uma lógica geral e mais uniforme.
Em 21/10/2023 às 15:14, Eli Almeidaa disse:Seria a forma que deixaria o código mais limpo e mais fácil de entender?
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:
Em 21/10/2023 às 15:14, Eli Almeidaa disse:funcao produtoExiste(nome:caractere):inteiro var resultado : inteiro contador : inteiro inicio para contador <- 1 ate quantidadeProdutosCadastrados faca se nome = produtos[contador].nome então resultado <- contador interrompa() fimse fimPara retorne resultado fimFuncao
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:
Em 18/10/2023 às 15:53, Simon Viegas disse:funcao produtoExiste (nome:caractere) : logico var contador : inteiro retorno : logico inicio retorno <- FALSO para contador <- 1 ate qtdProdutos faca se (produtos[contador].nome = nome) então retorno <- VERDADEIRO interrompa() fimSe fimPara retorne retorno fimFuncao
Obs.: eu mudei o nome da variável auxiliar de "existe" para "retorno", justamente para manter a coerência do restante do código."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:
Em 18/10/2023 às 15:53, Simon Viegas disse: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: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
Em 21/10/2023 às 15:14, Eli Almeidaa disse:Inicio quantidadeProdutoscadastrados <- 1
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
Em 21/10/2023 às 15:14, Eli Almeidaa disse:procedimento listarProduto() var contador : inteiro r, y : inteiro nome : caractere inicio y <- quantidadeProdutosCadastrados quantidadeProdutosCadastrados <- 1 nome <- "" r <- produtoExiste(nome) se (r = 0) e (r <> 1) então quantidadeProdutosCadastrados <- y
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:
Em 18/10/2023 às 15:53, Simon Viegas disse: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
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:
Em 18/10/2023 às 15:53, Simon Viegas disse:funcao existemProdutosCadastrados() : logico var retorno : logico inicio se (quantidadeProdutoscadastrados > 0) então retorno <- VERDADEIRO senao retorno <- FALSO fimSe retorne retorno fimFuncao
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.
-
2
-
1
-
-
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.
-
1
-
-
@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
18 horas atrás, Eli Almeidaa disse:const quantidadeMaximaProdutos = 2 tipo loja = registro nome: caractere preco: real estoque: inteiro fimRegistro var produtos: vetor [1..quantidadeMaximaProdutos] de loja quantidadeProdutosCadastrados, opcao, r, quantidade : inteiro nome, opcao2 : caractere
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
18 horas atrás, Eli Almeidaa disse: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 se quantidadeProdutosCadastrados <= quantidadeMaximaProdutos então cadastrarProduto() senao escreval(" Limite de cadastro atingido") fimSe caso 2 escreval ("Informe o nome do produto que deseja consultar o estoque") leia(nome) r <- produtoExiste(nome) se r > 0 então r <- consultarEstoque(nome) escreval(" A quantidade de estoque do produto ", nome, " é ", r:1) senao escreval(" Produto não cadastrado.") fimSe caso 3 escreval ("Informe o nome do produto que deseja atualizar o estoque") leia(nome) r <- produtoExiste(nome) se r > 0 então escreval ("[R] - retirar") escreval("[A] - adicionar") leia(opcao2) opcao2 <- maiusc(opcao2) se opcao2 = "R" então escreval ("Quanto gostaria de retirar") leia(quantidade) r <- atualizarEstoque(opcao2,quantidade) escreval("O novo estoque é de ", nome, " é ", r:1) senao se opcao2 = "A" então escreval ("Quanto gostaria de adicionar") leia(quantidade) r <- atualizarEstoque(opcao2,quantidade) escreval("O novo estoque é de ", nome, " é ", r:1) fimse fimse senao escreval(" Produto não cadastrado.") fimSe fimescolhaDeixar 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 fimProcedimentoDessa 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.
-
3
-
1
-
-
@devair1010, dá para simplificar simplesmente formatando os números. Exemplo:
algoritmo "Tabuada do 1 ao 10" // Data : 13/10/2023 var i,j : inteiro inicio escrevaL("Tabuada geral") escrevaL("") para i de 1 ate 10 faca escrevaL("") escrevaL(" Tabuada de ", i:1) escrevaL("") para j de 0 ate 10 faca escreva (i:2," x ", j:2, " = ") escrevaL(j*i:3) fimPara fimPara escrevaL(" ") escrevaL(" ") fimAlgoritmo
-
1
-
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
VisualG Modelo Bubble - sort Fila FIFO - as demais funções não são chamadas
em Programação - iniciantes
Postado
Só complementando:
O que é um FIFO?
É: “First in, first out”, traduzindo: "Primeiro a Entrar, Primeiro a Sair”¹)... por uma análise óbvia, uma fila só pode ser ordenada se a ordem for exatamente igual a original
. Se mudou a ordem, deixou de ser FIFO... O mesmo ocorre para FILO ("First In Last Out"), no caso de pilhas. Se "pode mexer na ordem", então seria uma "lista".
1 = lá ele