Melhor código para mostrar números perfeitos

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