Algoritimo Menor e Maior valor

[fabio-rocha2011@]

Pessoal preciso de uma ajuda não estou conseguindo fazer esse algoritimo:

Dado um conjunto de valores inteiros positivos, determine o maior e o menor valor do conjunto. O valor -1 indica o fim da entrada de dados e não deve ser considerado.

[Enock Gomes Neto]

Esta aqui o Algoritmo completo com todas as verificações (do jeito que você informou) feito no Visualg:

Teste e veja o resultado.

======================================================

algoritmo "MaiorMenorValor"
// Função : Descobrir o maior e o menor valor de um conjunto de numeros inteiros
// Autor : ENOCK GOMES NETO
// Data : 05/03/2011
// Seção de Declarações 
var
   menor, maior, i: inteiro
   numeros: vetor[0..100] de inteiro
inicio
   escreval("Digite os Valores (Para PARAR Digite -1)")
   escreval
   leia (numeros[0])
   se (numeros[0] >= 0) então
       menor <- numeros[0]
       maior <- numeros[0]
   senao
       se (numeros[0] = -1) então
           interrompa
           escreval
           escreval("O MENOR numero e", menor)
           escreval("O MAIOR numero e", maior)
           fimalgoritmo
       senao
           enquanto (numeros[0] < 0) faca
               escreval
               escreval ("Digite um Numero Inteiro Positivo")
               escreval
               leia (numeros[0])
               se (numeros[0] = -1) então
                   escreval
                   escreval("O MENOR numero e", menor)
                   escreval("O MAIOR numero e", maior)
                   fimalgoritmo
               fimse
           fimenquanto
           menor <- numeros[0]
           maior <- numeros[0]
       fimse
   fimse
   para i de 1 ate 99 faca
        leia (numeros[i])
        se (numeros[i] < 0 ) então
            se (numeros[i] = -1) então
                interrompa
            senao
                enquanto (numeros[i] < 0) faca
                    escreval
                    escreval ("Digite um Numero Inteiro Positivo")
                    escreval
                    leia (numeros[i])
                    se (numeros[i] = -1) então
                        escreval
                        escreval("O MENOR numero e", menor)
                        escreval("O MAIOR numero e", maior)
                        fimalgoritmo
                    fimse
                fimenquanto
            fimse
        senao
            se (menor > numeros[i]) então
                menor <- numeros[i]
            fimse
            se (maior < numeros[i]) então
               maior <- numeros[i]
            fimse
        fimse
   fimpara
   escreval
   escreval("O MENOR numero e", menor)
   escreval("O MAIOR numero e", maior)
fimalgoritmo

======================================================

Espero que tenha ajudado.

Atenciosamente,

Enock Gomes Neto

[B®µ₪o]

Eu gostaria de falar sobre um fator muito importante que pode acarretar em alguns probleminhas na execução de um algoritmo.

A quantidade de linhas de códigos

Bom, o software VisuAlg, é sem dúvidas uma grande alternativa para quem está dando os primeiros passos na área da programação, é um software que interpreta algoritmos escritos em português. Ele também é bastante util para verificar o desempenho dos algorítmos que desenvolvemos, assim como a velocidade de execução, em minhas pesquisas por algoritmos tenho visto muitos e muitos códigos feitos de uma maneira correta, porém, que podem ser melhorados e muito.

vou citar um exemplo clássico para quem está começando:

Faça um algoritmo que leia um número inteiro positivo qualquer e verifique se este número é primo ou não.

Bom, creio que muitos aqui irão fazer um laço de 1 até o número que o usuário digitar verificando se este número é divisor do número ou não, no final o algoritmo irá verificar a quantidade de divisores, se for igual a 2(dois) então o número é primo, caso contrário o número não é primo. Essa forma está correta, mas como eu disse acima, pode ser melhorada e muito. imagine se o usuário digitar o número 1.000.000(um milhão), quanto tempo não levaria para o VisuAlg efetuar este calculo?

É ai que entra um conhecimento básico de matemática misturado com lógica.

Observe que os divisores de qualquer número tirando ele mesmo, só vai até a metade do número, exemplo: O maior divisor do número 1.000.000(um milhão) tirando ele mesmo, é o número 500.000(quinhentos mil), e isso serve para qualquer número. Ou seja, do 500.000 até 1.000.000 o seu algoritmo não vai achar nenhum número que seja divisor de 1.000.000, e o programa irá varrer todos os números da mesma forma, causando lentidão na execução do programa e irritação por parte do usuário final, quem não fica irritado quando o computador trava por pelo menos uns 20 segundos?

Então, uma solução para esse problema seria dividir o número que o usuário digitar por 2, assim metade do problema vai embora.

outra questão envolvendo os números primos, TODOS OS NÚMEROS PRIMOS SÃO ÍMPARES, COM EXCEÇÃO DO NÚMERO 2(dois). Para solucionar esse outro problema, basta fazer com que o seu laço pule de 2 em dois pegando somente os números ímpares.

vamos supor que seu algoritmo levava 1 minuto e 30 segundos para ser executado, com essas dicas o programa irá executar os cálculos em apenas 22,5 segundos , ou seja, 1/4 de economia no tempo.

Conclusão, devemos tomar cuidado com lógicas que nos levam a desenvolver linhas de códigos desnecessárias.

Valeu galera, espero que essa dica sirva para alguém que está começando ai!

[Léo Ferreir?]

Só enriquecendo mais ainda o seu tópico:

var
   menor, maior, i: inteiro
   vetorx: vetor[0..10] de inteiro
inicio
   leia (vetorx[0])
   maior <- vetorx[0]
   menor <- vetorx[0]

      para i de 1 ate 9 faca
           leia(vetorx[i])
              se (vetorx[i]>maior) então
                    maior <- vetorx[i]
              fimse
                  se(vetorx[i]<menor) então
                      menor <- vetorx[i]
                  fimse
      fimpara

   escreval("Menor: ", menor)
   escreval("Maior: ", maior)

fimalgoritmo

Se tiver algum erro na sintaxe do Visualg, me desculpe. Há um tempão que não futuco no Visualg.