Melhor código para mostrar números perfeitos

[snowstormdelivery 19]

Pessoal, estou estudando lógica de programação e a apostila faz um desafio ao estudante, a qual pede que façamos um pseudocódigo que mostre os quatro primeiros números perfeitos.

Como pedido, eu fiz um código que mostra os quatro números, na verdade ele mostra TODOS, porém são muitos cálculos para mostrá-los de imediato. Levaria horas, dias ou meses para mostrar os 47 números perfeitos conhecidos da matemática.

Fiquei curioso para melhorar o código, e descobri no Wikipédia que existe uma fórmula para calcular números perfeitos, mas esta fórmula só calcula os quatro primeiros. Para o meu desafio estaria ótimo, mas eu queria saber como melhorar o primeiro código (que mostra todos), para ele escrever os 47 números (teoricamente, óbvio), sem demorar uma eternidade.

 

 

Aqui está o código que mostra todos os números perfeitos (ajustado para mostrar somente 4):

algoritmo "GeradorDeNúmerosPerfeitos"
var
Dividendo, Divisor, SomaDivis, NumPerfeito:inteiro
inicio
//Executa o código, enquanto a quantidade de números perfeitos não for igual a 4.
      Enquanto nao (NumPerfeito = 4) faca
         //Esta atribuição faz que o divendo aumente 1 número a cada laço.
         Dividendo := Dividendo + 1
         //Esta faz com que a soma de divisores, do dividendo anterior, resete.
         SomaDivis := 0
         //Este laço gera um número diferente a cada loop, verificando se ele é divisor do dividendo anterior.
         Para Divisor := 1 ate (Dividendo - 1) faca
            //Se for um divisor, atribui-se o valor dele a uma variável de soma: SomaDivis.
            Se ( Dividendo % Divisor = 0) entao
               SomaDivis := SomaDivis + Divisor
               //Esta variável verifica se a soma de divisores é maior que o dividendo, se for, ele estoura o loop, acelerando a procura.
               Se (SomaDivis > Dividendo) entao
                  Divisor := (Dividendo - 1)
               FimSe
            FimSe
         FimPara
         //Se a soma de divisores for igual ao dividendo, ele escreve o valor do dividendo e soma 1 na variável de controle DivisPerfeito.
         Se (SomaDivis = Dividendo) entao
            Escreva (Dividendo)
            NumPerfeito := NumPerfeito + 1
         FimSe
      FimEnquanto
      //Fim do algoritmo quando o a quantidade de números perfeitos é igual a 4.
fimalgoritmo

Aqui está o código que mostra somente 4 números perfeitos, se quiserem olhar:

algoritmo "4NúmerosPerfeitos"
var
Primo, Dividendo, Divisor, ContDivis, NumPrimos:inteiro
NumPerfeito: real
inicio
// Este código se repete até o número de primos ser igual a 4, pois utiliza-se
//a fórmula de Euclides, a qual só usa os quatro primeiros primos e só mostra
//os quatro primeiros números perfeitos.
   Repita
      // Estas atribuições resetam o valor das variáveis para o código gerar um
      //novo número primo, sem causar conflitos.
      ContDivis := 0
      Primo := 0
      // Com a variável "Primo" resetada, pode-se iniciar o código para gerar
      //um novo número primo.
      Enquanto (Primo = 0) faca
         // O dividendo é o número que poderá vir a se tonar um primo, caso
         //possua 2 divisores, por isso ele aumenta 1 numero a cada loop.
         Dividendo :=  Dividendo + 1
         ContDivis := 0
         Para Divisor := 1 ate (Dividendo) faca
            //Esta condição conta quantos divisores o dividendo anterior possui.
            Se (Dividendo % Divisor = 0) entao
               ContDivis := ContDivis + 1
            FimSe
         FimPara
         // Se o dividendo anterior possuir dois divisores, ele é primo.
         Se (ContDivis = 2) entao
            Primo := Dividendo
            NumPrimos := NumPrimos + 1
         FimSe
      // Se houver algum número primo, o laço do "Enquanto" estoura.
      FimEnquanto
      // Calcula-se o número perfeito, à partir do número primo com a
      //fórmula de Euclides.
      NumPerfeito := ((2^(Primo - 1)) * ((2 ^ Primo) - 1))
      Se (NumPrimos = 4) entao
         Escreva (NumPerfeito,".")
      Senao
         Escreva (NumPerfeito,",")
      FimSe
   // Se já foi gerado quatro números primos, logo, quatro números perfeitos,
   //o programa encerra.
   Ate (NumPrimos =  4)
fimalgoritmo

[KhaosDoctor 242]

Para diminuir o tempo de processamento você pode diminuir a quantidade de laços, comece a usar recursão que é muito mais amigável para o sistema. Cada laço aumenta muito a complexidade e o uso de memória.

 

Evite utilizar strings grandes para concatenar valores de exibição, use principalmente arrays.

 

Separe seu código em rotinas e procedimentos que vão ajudar no reuso da memória e no entendimento. Infelizmente o Portugol é lento mesmo, mas aplicando essas práticas a uma linguagem de alto nível você teria um bom desempenho.

[snowstormdelivery 19]

Não usei recursividade, porque o exercício pedia somente estruturas de repetição e condições, sem usar funções ou procedimentos. Mas vou fazer isso, por fora do exercício. Valeu!