Crie um programa e um algoritmo para listar os 4 primeiros números perfeitos.

Fala galera da programação, tudo beleza?

Hoje vamos fazer um exercício com números perfeitos. Para quem quiser saber mais sobre o que são os números perfeitos, recomendamos a leitura do nosso post que explica em detalhes o tema.

Números Perfeitos na Matemática: Uma Exploração dos Números Divinos

Legal, agora que você já sabe o que é um número perfeito, vamos ao exercício.

Basicamente pessoal, recomendo que seja feita uma função que verifica se um número é ou não um número perfeito, e depois criar um laço para ir percorrendo os números até encontrar os 4 primeiros.

Por que apenas quatro?

Por hora pessoal, pode ser que o computador demore muito para calcular a partir do quinto número. Beleza? Então vamos aos códigos:

Exemplo em C++

/*

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

*/

#include <iostream>
#include <cmath>

bool ehNumeroPerfeito(int num) {
    int somaDivisores = 1;  // Começamos com 1, pois todo número é divisível por 1
    int limite = sqrt(num);  // Apenas precisamos verificar até a raiz quadrada de num

    for (int i = 2; i <= limite; i++) {
        if (num % i == 0) {
            somaDivisores += i;
            if (i != num / i) {
                // Evita contar o mesmo divisor duas vezes se num for um quadrado perfeito
                somaDivisores += num / i;
            }
        }
    }

    return somaDivisores == num;
}

int main() {
    int contador = 0;
    int candidato = 6;  // Começamos a busca a partir do primeiro número perfeito conhecido

    std::cout << "Os 4 primeiros numeros perfeitos sao:" << std::endl;

    while (contador < 4) {
        if (ehNumeroPerfeito(candidato)) {
            std::cout << candidato << std::endl;
            contador++;
        }
        
        // porque os números perfeitos são pares
        candidato++;
        
    }

    return 0;
}

Explicação

1. Função ehNumeroPerfeito:
   • Recebe um número inteiro (num) como parâmetro.
   • Inicializa uma variável somaDivisores com o valor 1, pois todo número é divisível por 1.
   • Calcula o limite de iteração (limite) como a raiz quadrada de num. Isso é feito para otimizar o loop de verificação de divisores.
   • Utiliza um loop for para iterar de 2 até limite:
     • Verifica se num é divisível por i.
     • Se for divisível, adiciona i à somaDivisores.
     • Verifica se i é diferente de num / i para evitar contar o mesmo divisor duas vezes se num for um quadrado perfeito.
       • Se verdadeiro, adiciona num / i à somaDivisores.
   • Retorna true se a somaDivisores for igual a num, indicando que num é um número perfeito. Caso contrário, retorna false.
2. Função main:
   • Inicializa um contador para rastrear quantos números perfeitos foram encontrados.
   • Inicializa o primeiro candidato a número perfeito como 6, que é o menor número perfeito conhecido.
   • Utiliza um loop while para encontrar os 10 primeiros números perfeitos:
     • Chama a função ehNumeroPerfeito para verificar se o candidato é um número perfeito.
     • Se verdadeiro, imprime o candidato e incrementa o contador.
     • Incrementa o candidato para verificar o próximo número.

O algoritmo continua esse processo até encontrar os 4 primeiros números perfeitos e os imprime na tela. Este é um algoritmo simples, mas eficiente o suficiente para encontrar números perfeitos.

Exemplo em Pascal

(*

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

*)
program NumerosPerfeitos;

function EhNumeroPerfeito(num: Integer): Boolean;
var
  somaDivisores, i, limite: Integer;
begin
  somaDivisores := 1;  // Começamos com 1, pois todo número é divisível por 1
  limite := Trunc(Sqrt(num));  // Apenas precisamos verificar até a raiz quadrada de num

  for i := 2 to limite do
  begin
    if num mod i = 0 then
    begin
      somaDivisores := somaDivisores + i;
      
      if i <> num div i then
      begin
        // Evita contar o mesmo divisor duas vezes se num for um quadrado perfeito
        somaDivisores := somaDivisores + num div i;
      end;
    end;
  end;

  EhNumeroPerfeito := somaDivisores = num;
end;

var
  contador, candidato: Integer;
begin
  contador := 0;
  candidato := 6;  // Começamos a busca a partir do primeiro número perfeito conhecido

  writeln('Os 4 primeiros numeros perfeitos sao:');

  while contador < 4 do
  begin
    if EhNumeroPerfeito(candidato) then
    begin
      writeln(candidato);
      Inc(contador);
    end;
    Inc(candidato);
  end;
end.

Este é o equivalente em Pascal do algoritmo que lista os 4 primeiros números perfeitos. O código utiliza uma lógica semelhante que a versão em C++, mas está adaptado à sintaxe da linguagem de programação Pascal.

Exemplo em Python

'''

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

'''
def eh_numero_perfeito(num):
    soma_divisores = 1  # Começamos com 1, pois todo número é divisível por 1
    limite = int(num**0.5) + 1  # Apenas precisamos verificar até a raiz quadrada de num

    for i in range(2, limite):
        if num % i == 0:
            soma_divisores += i

            if i != num // i:
                # Evita contar o mesmo divisor duas vezes se num for um quadrado perfeito
                soma_divisores += num // i

    return soma_divisores == num

def main():
    contador = 0
    candidato = 6  # Começamos a busca a partir do primeiro número perfeito conhecido

    print("Os 4 primeiros numeros perfeitos sao:")

    while contador < 4:
        if eh_numero_perfeito(candidato):
            print(candidato)
            contador += 1
        candidato += 1

if __name__ == "__main__":
    main()

Este é o equivalente em Python do algoritmo que lista os 4 primeiros números perfeitos. O código utiliza a mesma lógica, mas está adaptado à sintaxe da linguagem Python.

Exemplo em C#

/*

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

*/

using System;

class Program
{
    static bool EhNumeroPerfeito(int num)
    {
        int somaDivisores = 1;  // Começamos com 1, pois todo número é divisível por 1
        int limite = (int)Math.Sqrt(num) + 1;  // Apenas precisamos verificar até a raiz quadrada de num

        for (int i = 2; i < limite; i++)
        {
            if (num % i == 0)
            {
                somaDivisores += i;

                if (i != num / i)
                {
                    // Evita contar o mesmo divisor duas vezes se num for um quadrado perfeito
                    somaDivisores += num / i;
                }
            }
        }

        return somaDivisores == num;
    }

    static void Main()
    {
        int contador = 0;
        int candidato = 6;  // Começamos a busca a partir do primeiro número perfeito conhecido

        Console.WriteLine("Os 4 primeiros numeros perfeitos sao:");

        while (contador < 4)
        {
            if (EhNumeroPerfeito(candidato))
            {
                Console.WriteLine(candidato);
                contador++;
            }
            candidato++;
        }
    }
}

Este é o código em C# equivalente ao algoritmo que lista os 4 primeiros números perfeitos. A lógica é a mesma, mas a sintaxe foi adaptada para C#.

Exemplo em JAVA

/*

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

*/

public class NumerosPerfeitos {

    static boolean ehNumeroPerfeito(int num) {
        int somaDivisores = 1;  // Começamos com 1, pois todo número é divisível por 1
        int limite = (int) Math.sqrt(num) + 1;  // Apenas precisamos verificar até a raiz quadrada de num

        for (int i = 2; i < limite; i++) {
            if (num % i == 0) {
                somaDivisores += i;

                if (i != num / i) {
                    // Evita contar o mesmo divisor duas vezes se num for um quadrado perfeito
                    somaDivisores += num / i;
                }
            }
        }

        return somaDivisores == num;
    }

    public static void main(String[] args) {
        int contador = 0;
        int candidato = 6;  // Começamos a busca a partir do primeiro número perfeito conhecido

        System.out.println("Os 4 primeiros numeros perfeitos sao:");

        while (contador < 4) {
            if (ehNumeroPerfeito(candidato)) {
                System.out.println(candidato);
                contador++;
            }
            candidato++;
        }
    }
}

Este é o código em Java equivalente ao algoritmo que lista os 4 primeiros números perfeitos. A lógica permanece a mesma, mas a sintaxe foi adaptada para Java.

Beleza pessoal.Espero que possa ajudar.

Dúvidas ou sugestões de outras linguagens? Deixe o seu comentário.

Um abraço e até o próximo post. Valeu!