VisualG Maior e menor entre 5 números

[fuzzicosta]

Elabore um algoritmo que leia 5 valores inteiros e apresente na tela o maior e o menor deles.

 

Só que o problema é quando pede para digitar o segundo ao quinto valor ele informa 0 ao invés de informa 2 3 4 5 por sequência, alguém que entende de programação poderia resolver isso para mim por favor, estou precisando muito, construí no Visualg pois sou iniciante.

algoritmo "Maior valor"
var
   valores: vetor [1..5] de inteiro
   Maior, menor, contador: inteiro
inicio
   escreva("Digite o 1 valor: ")
   leia(valores[1])
   menor<-valores[1]
   para contador de 2 ate 5 faca
      escreva("Digite o ",valores[contador]," valor: ")
      leia(valores[contador])
      se (valores[contador]>maior) então
         maior<-valores[contador]
      fimse
      se (valores[contador]<menor) então
         menor<-valores[contador]
      fimse
   fimpara
   escreval("Maior valor: ",maior)
   escreval("Menor valor: ", menor)
fimalgoritmo

 

[Olinad212]

Nunca fiz um programa no VisualG, mas sei que ele simula a execução de programa a partir de código escrito em portugol.

 

Uma dúvida: o seu programa está executando normalmente, tendo como saída o maior e o menor valor digitado? O único erro seria a exibição de 0 na posição do vetor?

[Simon Viegas]

Olá @fuzzicosta.

 

Em 24/03/2018 às 12:56, fuzzicosta disse:

Só que o problema é quando pede para digitar o segundo ao quinto valor ele informa 0 ao invés de informa 2 3 4 5 por sequência

 

Veja, o principal você já tem: o local.

 

Você apenas está exibindo o valor errado.

 

Segue o código:

algoritmo "Maior valor"
var
   valores: vetor [1..5] de inteiro
   Maior, menor, contador: inteiro
inicio
   escreva("Digite o 1 valor: ")
   leia(valores[1])
   menor<-valores[1]
   para contador de 2 ate 5 faca
      //escreva("Digite o ",valores[contador]," valor: ")
      escreva("Digite o",contador," valor: ")
      leia(valores[contador])
      se (valores[contador]>maior) ENTÃO
         maior<-valores[contador]
      fimse
      se (valores[contador]<menor) ENTÃO
         menor<-valores[contador]
      fimse
   fimpara
   escreval("Maior valor: ",maior)
   escreval("Menor valor: ",menor)
fimalgoritmo

 

 

1) CONDIÇÕES MUTUAMENTE EXCLUDENTES

Se um número é "maior", ele não poderá ser "menor" também (são excludentes), logo, devem-se usar o senão. Ficaria algo assim:

      se (valores[contador]>maior) ENTÃO
         maior<-valores[contador]
      senao
         se (valores[contador]<menor) ENTÃO
            menor<-valores[contador]
         fimse
      fimse

 

 

 

2) RECURSO PARA TESTES

Uma maneira simples e prática para efetuar os testes, é utilizando o comando ALEATORIO. Ex.:

   ALEATORIO 0,1000
   escreva("Digite o 1 valor: ")
   leia(valores[1])
   menor<-valores[1]
   ALEATORIO OFF
   para contador de 2 ate 5 faca
      //escreva("Digite o ",valores[contador]," valor: ")
      ALEATORIO 0,1000
      escreva("Digite o",contador," valor: ")
      leia(valores[contador])
      ALEATORIO OFF

 

 

 

***

 

Por ai vai.

 

Qualquer dúvida é só pergunta.

 

 

No aguardo.

[fuzzicosta]

Em 24/03/2018 às 12:21, Olinad212 disse:

Nunca fiz um programa no VisualG, mas sei que ele simula a execução de programa a partir de código escrito em portugol.

 

Uma dúvida: o seu programa está executando normalmente, tendo como saída o maior e o menor valor digitado? O único erro seria a exibição de 0 na posição do vetor?

Exatamente isso, único problema quando ele pula do veto 1 para o segundo ele coloca 0 ao invés de colocar números 2,3,4,5 esse único problema, mas ele esta executando corretamente

[devair1010]

@fuzzicosta    esse erro que você disse é por que você usou a variável errada lá dentro do loop na hora de pegar o valor digitado , você colocou assim :

para contador de 2 ate 5 faca
      escreva("Digite o ",valores[contador]," valor: ")
      leia(valores[contador])
      se (valores[contador]>maior) então

mas teria que ser como @Simon Viegas   postou assim :

para contador de 2 ate 5 faca
      escreva("Digite o ",contador," valor: ")
      leia(valores[contador])
      se (valores[contador]>maior) então

 

[fuzzicosta]

Obrigado pessoal consegui resolver no Domingo parta da manhã, erro era na linha (11), escreva("Digite o ",valores[contador]," valor: "). Exclui valores e tirei os [ ] que ficou assim > escreva("Digite o ",contador," valor: ").

Veja como ficou abaixo depois de eu mexer nele, Obrigado pela ajuda, vou precisar mas de suas ajudas aqui em diante conto com vocês, pois estou estudando algoritmo e quero aprender a fazer.

algoritmo "Maior valor e Menor valor"
var
   valores: vetor [1..5] de inteiro
   Maior, menor, contador: inteiro
inicio
   para contador de 1 ate 5 faca
      escreva("Digite o ",contador," valor: ")
      leia(valores[contador])
      se (valores[contador]>maior) então
         maior<-valores[contador]
      fimse
      se (valores[contador]<menor) então
         menor<-valores[contador]
      fimse
   fimpara
   escreval("Maior valor: ",maior)
   escreval("Menor valor: ", menor)
fimalgoritmo

 

[Ricardov]

@fuzzicosta Dica: https://www.clubedohardware.com.br/announcement/27-poste-seus-códigos-corretamente/

[Simon Viegas]

Olá @fuzzicosta.

 

 

1) TESTES DE FUNCIONALIDADE

Para simplificar os testes, e ao mesmo tempo demonstrar como foi feito, segue um código:

algoritmo "Maior valor e Menor valor"
var
   valores: vetor [1..5] de inteiro
   Maior, menor, contador: inteiro
inicio
   para contador de 1 ate 5 faca
      ALEATORIO 1,100 //PARA EFETUAR TESTES, apenas inserir essa linha
      escreva("Digite o ",contador," valor: ")
      leia(valores[contador])
      ALEATORIO OFF //e essa linha
      se (valores[contador]>maior) ENTÃO
         maior<-valores[contador]
      fimse
      se (valores[contador]<menor) ENTÃO
         menor<-valores[contador]
      fimse
   fimpara
   escreval("Maior valor: ",maior)
   escreval("Menor valor: ", menor)
fimalgoritmo

Segue um exemplo de resultado:

 

Ou seja, o menor não funcionou.

 

Como faltou apenas "inicializar" o menor, como tinha feito:

Em 24/03/2018 às 12:56, fuzzicosta disse:

inicio
   escreva("Digite o 1 valor: ")
   leia(valores[1])
   menor<-valores[1]
   para contador de 2 ate 5 faca

 

Segue o código corrigido (incluindo o recurso para gerar números) para servir de base para outros usuário também.

algoritmo "Maior valor e Menor valor"
var
   valores: vetor [1..5] de inteiro
   Maior, menor, contador: inteiro
inicio
   ALEATORIO 1,100 //recurso para gerar números automaticamente (simula o usuário digitando)
   escreva("Digite o 1 valor: ")
   leia(valores[1])
   menor<-valores[1]
   ALEATORIO OFF //interrempe o recurso de "gerar números"
   para contador de 2 ate 5 faca //verifica a partir do segundo
      ALEATORIO 1,100 //recurso para gerar números automaticamente (simula o usuário digitando)
      escreva("Digite o",contador," valor: ")
      leia(valores[contador])
      ALEATORIO OFF //interrempe o recurso de "gerar números"
      se (valores[contador]>maior) ENTÃO
         maior<-valores[contador]
      fimse
      se (valores[contador]<menor) ENTÃO
         menor<-valores[contador]
      fimse
   fimpara
   escreval("Maior valor:",maior)
   escreval("Menor valor:",menor)
fimalgoritmo

Obs.: para o "código final", remova essas linhas do ALEATORIO.

 

 

Uma outra forma de fazer gerar os número seria:

algoritmo "Maior valor e Menor valor"
var
   valores: vetor [1..5] de inteiro
   Maior, menor, contador: inteiro
inicio
   ALEATORIO 1,100 //recurso para gerar números automaticamente (simula o usuário digitando)
   escreva("Digite o 1 valor: ")
   leia(valores[1])
   menor<-valores[1]
   para contador de 2 ate 5 faca //verifica a partir do segundo
      escreva("Digite o",contador," valor: ")
      leia(valores[contador])
      se (valores[contador]>maior) ENTÃO
         maior<-valores[contador]
      fimse
      se (valores[contador]<menor) ENTÃO
         menor<-valores[contador]
      fimse
   fimpara
   ALEATORIO OFF //interrempe o recurso de "gerar números"
   escreval("Maior valor:",maior)
   escreval("Menor valor:",menor)
fimalgoritmo

Ou seja, resumidamente, todo leia() que estiver entre o par de ALEATORIO, vai ser auto-preenchido com um valor aleatório, no caso entre a faixa escolhida (no ex.: entre 1 e 100).

 

 

ADENDO:

Essa dica continua válida:

 

Em 25/03/2018 às 17:40, Simon Viegas disse:

1) CONDIÇÕES MUTUAMENTE EXCLUDENTES

Se um número é "maior", ele não poderá ser "menor" também (são excludentes), logo, devem-se usar o senão. Ficaria algo assim:

      se (valores[contador]>maior) ENTÃO
         maior<-valores[contador]
      senao
         se (valores[contador]<menor) ENTÃO
            menor<-valores[contador]
         fimse
      fimse

 

Caso não tenha estudado o se/senão, ignore. Caso já tenha estudado... é necessário corrigir isso (será um "erro")!

 

 

Fazendo uma "brincadeira com o tema, seria:

se (JaEstudeiSeSenao=VERDADEIRO) ENTÃO
   corrigirCodigo()
senao
   se (JaEstudeiSeSenao=FALSO) ENTÃO
      ingnorarSugestao()

Observe que as possibilidades para JaEstudeiSeSenao é booleana (da álgebra booleana), ou seja, só existem duas possibilidades. Daí poderia fica assim:

se (JaEstudeiSeSenao=VERDADEIRO) ENTÃO
   corrigirCodigo()
senao
   ingnorarSugestao()

ou seja, se não é verdadeira, necessariamente será falsa.

 

 

CONCLUSÃO
- As possibilidades envolvidas são excludentes entre si (se for uma, jamais poderá ser a outra), logo "necessita" do senão.

Exemplos.:

Se é verdadeiro, não pode ser falso.

Se é maior, não pode ser menor (obs.: a não ser que seja o primeiro termo)

Se salario<1000, não pode ser (salario>=1000) e (salario<1500).

Etc

 

- Em condições onde não existem mais outras possibilidades, não é necessário verificar novamente.

Exemplo:

Se não é verdadeiro, então falso.

Se não for masculino, senão, se não for feminino, então será "não informado"

Se não é salario<1000, necessariamente será maior ou igual a 1000.

Etc

 

- No contexto do Maior e Menor, perceba que não só existem essas duas possibilidades, ou seja, pode não ser Maior e também pode não ser Menor, daí é necessário usar o senão (por que se for uma não será um outro), mas necessita também do se para outro (pois pode ser nenhum dos dois)

 

***

 

Att

 

 

 

[Maninho Visualg]

algoritmo "Maior valor e Menor valor"
var
   valores: vetor [1..5] de inteiro
   maior, menor, contador: inteiro
inicio
   para contador de 1 ate 5 faca
         escreva("Digite o",contador,"º valor: ")
         leia(valores[contador])

         se contador = 1 entao
            maior<-valores[contador]
            menor<-valores[contador]
         fimse

         se (valores[contador]>maior) entao
            maior<-valores[contador]
         fimse

         se (valores[contador]<menor) entao
            menor<-valores[contador]
         fimse
   fimpara
   escreval("Maior valor: ",maior)
   escreval("Menor valor: ", menor)
fimalgoritmo

 

[Leonardo7]

Como fixaria isso em linguagem java? alguém pode me falar.