一个数如果恰好等于它的因子之和，这个数就称为“完数“。例如6=1＋2＋3.编程找出1000以内的所有完数。-多语言

目录

C 语言实现

Python 实现

Java 实现 

Js 实现

---

题目：一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如6=1＋2＋3.编程找出1000以内的所有完数。

完数（Perfect Number）是一个正整数，它等于其所有正因子（不包括自身）的和。换句话说，如果一个数 n 的所有正因子（除了 n 本身）相加的结果等于 n，那么 n 就是一个完数。

完数的性质

• 完数是稀有的，已知的完数都是偶数。

• 根据欧几里得的定理，完数可以通过以下公式生成： n=2p−1×(2p−1) 其中 2p−1 是一个质数（称为梅森质数）。

• 例如，当 p=2 时，22−1=3 是质数，因此 n=22−1×3=6 是完数。

• 当 p=3 时，23−1=7 是质数，因此 n=23−1×7=28 是完数。

结论

完数在数论中是一个有趣的概念，尽管它们相对稀少，但它们在数学研究中具有重要的意义。已知的完数包括 6、28、496、8128 等。

C 语言实现

#include 
#define N 1000

int main() {
    int i, j, k, n, sum;
    int a[256]; // 用于存储因子

    // 遍历从 2 到 N 的每个数
    for (i = 2; i <= N; i++) {
        sum = a[0] = 1; // 初始化 sum 和因子数组的第一个元素
        k = 0; // 因子计数器

        // 查找 i 的所有因子
        for (j = 2; j <= (i / 2); j++) {
            if (i % j == 0) {
                sum += j; // 累加因子
                a[++k] = j; // 存储因子
            }
        }

        // 检查是否为完数
        if (i == sum) {
            printf("%d = %d", i, a[0]); // 打印完数及其第一个因子
            for (n = 1; n <= k; n++) {
                printf(" + %d", a[n]); // 打印其他因子
            }
            printf("\n"); // 换行
        }
    }

    return 0; // 返回 0 表示程序正常结束
}

1. 头文件和宏定义: #include 用于引入标准输入输出库，#define N 1000 定义了常量 N，表示要查找的范围。
2. 变量声明: 声明整型变量 i、j、k、n 和 sum，以及一个数组 a 用于存储因子。
3. 外层循环: 遍历从 2 到 N 的每个数 i。
4. 初始化: 将 sum 初始化为 1（因子 1），并将 k 初始化为 0（因子计数器）。
5. 内层循环: 查找 i 的所有因子，遍历从 2 到 i/2 的每个数 j。
   • 如果 i 能被 j 整除，则 j 是 i 的因子，累加到 sum 中，并存储在数组 a 中。
6. 完数检查: 如果 sum 等于 i，则打印出 i 及其因子。
7. 输出格式: 打印完数及其因子和，格式为 i = 1 + j1 + j2 + ...。
8. 程序结束: return 0; 表示程序正常结束。

Python 实现

def find_perfect_numbers(limit):
    for i in range(2, limit + 1):
        sum_of_divisors = 1  # 初始化因子和为 1（包括 1）
        divisors = [1]  # 存储因子，初始包含 1

        # 查找 i 的所有因子
        for j in range(2, i // 2 + 1):
            if i % j == 0:
                sum_of_divisors += j  # 累加因子
                divisors.append(j)  # 存储因子

        # 检查是否为完数
        if i == sum_of_divisors:
            # 打印完数及其因子
            print(f"{i} = {' + '.join(map(str, divisors))}")

# 调用函数，查找 1 到 1000 之间的完数
find_perfect_numbers(1000)

1. 函数定义: 定义 find_perfect_numbers(limit) 函数，接受一个参数 limit，表示查找的范围。
2. 外层循环: 使用 for 循环遍历从 2 到 limit 的每个数 i。
3. 初始化: 将 sum_of_divisors 初始化为 1（因子 1），并创建一个列表 divisors 用于存储因子，初始包含 1。
4. 内层循环: 查找 i 的所有因子，遍历从 2 到 i // 2 的每个数 j。
   • 如果 i 能被 j 整除，则 j 是 i 的因子，累加到 sum_of_divisors 中，并存储在 divisors 列表中。
5. 完数检查: 如果 sum_of_divisors 等于 i，则打印出 i 及其因子。
6. 输出格式: 使用 join() 方法将因子列表转换为字符串，格式为 i = 1 + j1 + j2 + ...。

Java 实现 

import java.util.ArrayList;
import java.util.List;

public class PerfectNumberFinder {
    public static void main(String[] args) {
        findPerfectNumbers(1000);
    }

    public static void findPerfectNumbers(int limit) {
        // 遍历从 2 到 limit 的每个数
        for (int i = 2; i <= limit; i++) {
            int sumOfDivisors = 1; // 初始化因子和为 1（包括 1）
            List divisors = new ArrayList<>(); // 存储因子
            divisors.add(1); // 初始包含 1

            // 查找 i 的所有因子
            for (int j = 2; j <= i / 2; j++) {
                if (i % j == 0) {
                    sumOfDivisors += j; // 累加因子
                    divisors.add(j); // 存储因子
                }
            }

            // 检查是否为完数
            if (i == sumOfDivisors) {
                // 打印完数及其因子
                System.out.print(i + " = " + divisors.get(0)); // 打印第一个因子
                for (int n = 1; n < divisors.size(); n++) {
                    System.out.print(" + " + divisors.get(n)); // 打印其他因子
                }
                System.out.println(); // 换行
            }
        }
    }
}

1. 导入类: import java.util.ArrayList; 和 import java.util.List; 用于使用动态数组存储因子。
2. 主类定义: 定义 PerfectNumberFinder 类。
3. 主方法: public static void main(String[] args) 是程序的入口，调用 findPerfectNumbers(1000) 方法。
4. 方法定义: public static void findPerfectNumbers(int limit) 方法用于查找完数。
5. 外层循环: 遍历从 2 到 limit 的每个数 i。
6. 初始化: 将 sumOfDivisors 初始化为 1（因子 1），并创建一个 ArrayList 用于存储因子，初始包含 1。
7. 内层循环: 查找 i 的所有因子，遍历从 2 到 i / 2 的每个数 j。
   • 如果 i 能被 j 整除，则 j 是 i 的因子，累加到 sumOfDivisors 中，并存储在 divisors 列表中。
8. 完数检查: 如果 sumOfDivisors 等于 i，则打印出 i 及其因子。
9. 输出格式: 打印完数及其因子和，格式为 i = 1 + j1 + j2 + ...。

Js 实现

function findPerfectNumbers(limit) {
    // 遍历从 2 到 limit 的每个数
    for (let i = 2; i <= limit; i++) {
        let sumOfDivisors = 1; // 初始化因子和为 1（包括 1）
        let divisors = [1]; // 存储因子，初始包含 1

        // 查找 i 的所有因子
        for (let j = 2; j <= i / 2; j++) {
            if (i % j === 0) {
                sumOfDivisors += j; // 累加因子
                divisors.push(j); // 存储因子
            }
        }

        // 检查是否为完数
        if (i === sumOfDivisors) {
            // 打印完数及其因子
            let output = `${i} = ${divisors[0]}`; // 打印第一个因子
            for (let n = 1; n < divisors.length; n++) {
                output += ` + ${divisors[n]}`; // 打印其他因子
            }
            console.log(output); // 输出结果
        }
    }
}

// 调用函数，查找 1 到 1000 之间的完数
findPerfectNumbers(1000);

1. 函数定义: 定义 findPerfectNumbers(limit) 函数，接受一个参数 limit，表示查找的范围。
2. 外层循环: 使用 for 循环遍历从 2 到 limit 的每个数 i。
3. 初始化: 将 sumOfDivisors 初始化为 1（因子 1），并创建一个数组 divisors 用于存储因子，初始包含 1。
4. 内层循环: 查找 i 的所有因子，遍历从 2 到 i / 2 的每个数 j。
   • 如果 i 能被 j 整除，则 j 是 i 的因子，累加到 sumOfDivisors 中，并存储在 divisors 数组中。
5. 完数检查: 如果 sumOfDivisors 等于 i，则打印出 i 及其因子。
6. 输出格式: 使用模板字符串构建输出格式，格式为 i = 1 + j1 + j2 + ...，并使用 console.log() 输出结果。