简单的哥德巴赫猜想验证

晓嘿君2025-04-282025-04-28

代码功能概述

这段代码的主要目的是验证 哥德巴赫猜想：
任何大于 2 的偶数都可以表示为两个素数之和。

程序的具体任务是：

遍历 6 到 100 之间的所有偶数。
对于每个偶数，尝试将其分解为两个素数的和。
打印出所有满足条件的分解形式。

**完整代码

#include <stdio.h>

// 判断一个数是否为素数
int sushu(int n) {
    for (int i = 2; i * i <= n; i++) {
        if (n % i == 0) {
            return 0; // 不是素数
        }
    }
    return 1; // 是素数
}

// 寻找偶数的哥德巴赫分解
int gdbh(int n, int oushu) {
    if (n > oushu / 2) {
        return 0; // 超过一半，无需继续
    }
    if (sushu(n) && sushu(oushu - n)) {
        printf("%d=%d+%d\n", oushu, n, oushu - n);
        return 0; // 找到一组解
    }
    gdbh(n + 1, oushu); // 继续寻找
}

int main() {
    // 遍历6到100之间的所有偶数
    for (int n = 6; n <= 100; n = n + 2) {
        gdbh(2, n); // 从2开始寻找哥德巴赫分解
    }
    return 0;
}

代码结构分析

代码分为以下几个部分：

1. 判断一个数是否为素数

函数 sushu(int n)：

输入一个整数 n，判断它是否为素数。
素数的定义是：除了 1 和自身以外，不能被其他正整数整除。
使用循环从 2 开始，检查是否有小于等于 sqrt(n)的数能整除n。
如果找到能整除的数，则返回 0（不是素数）；否则返回 1（是素数）。

2. 寻找偶数的哥德巴赫分解

函数 gdbh(int n, int oushu)：

输入当前尝试的数 n和目标偶数oushu。
检查 n 和 oushu - n 是否都是素数。
如果是，则打印出分解形式 oushu = n + (oushu - n)。
如果不是，则递归调用 gdbh，将 n 增加 1，继续寻找其他可能的分解。

3. 主函数逻辑

主函数 main()：

遍历 6 到 100 之间的所有偶数。
对每个偶数调用 gdbh(2, n)，从 2 开始寻找其哥德巴赫分解。

运算步骤详解

1. 初始化和遍历偶数

主函数 main() 中的循环：

for (int n = 6; n <= 100; n = n + 2) {
    gdbh(2, n);
}

从 n = 6开始，每次增加 2，直到n = 100。
对于每个偶数 n，调用 gdbh(2, n)，从 2 开始寻找两个素数的和。

2. 寻找哥德巴赫分解

函数 gdbh(int n, int oushu) 的逻辑：

if (n > oushu / 2) {
    return 0;
}

如果当前尝试的数 n已经超过 oushu / 2，则无需继续搜索，因为分解形式会重复（例如8 = 3 + 5和8 = 5 + 3 是等价的）。

if (sushu(n) && sushu(oushu - n)) {
    printf("%d=%d+%d\n", oushu, n, oushu - n);
    return 0;
}

检查 n和oushu - n 是否都是素数。
如果是，则打印分解形式，例如 6 = 3 + 3。
返回 0 表示已经找到一组解。

gdbh(n + 1, oushu);

如果当前 n不符合条件，则递归调用gdbh(n + 1, oushu)，继续尝试下一个数。

3. 判断素数

函数 sushu(int n) 的逻辑：

for (int i = 2; i * i <= n; i++) {
    if (n % i == 0) {
        return 0;
    }
}
return 1;

从 i = 2开始，检查是否有小于等于sqrt(n)的数能整除n。
如果找到能整除的数，返回 0（不是素数）。
如果没有找到，返回 1（是素数）。

具体运行示例

假设我们处理偶数 10，以下是详细的运算步骤：

主函数调用 gdbh(2, 10)：
- 当前尝试的数 n = 2，目标偶数 oushu = 10。
第一次调用 gdbh(2, 10)：
- 检查 n > oushu / 2：2 > 10 / 2 不成立，继续。
- 检查 sushu(2) 和 sushu(10 - 2)：
  - sushu(2)：是素数，返回 1。
  - sushu(8)：不是素数，返回 0。
- 条件不满足，递归调用 gdbh(3, 10)。
第二次调用 gdbh(3, 10)：
- 检查 n > oushu / 2：3 > 10 / 2 不成立，继续。
- 检查 sushu(3) 和 sushu(10 - 3)：
  - sushu(3)：是素数，返回 1。
  - sushu(7)：是素数，返回 1。
- 条件满足，打印 10 = 3 + 7，返回 0。
第三次调用 gdbh(4, 10)：
- 检查 n > oushu / 2：4 > 10 / 2 不成立，继续。
- 检查 sushu(4) 和 sushu(10 - 4)：
  - sushu(4)：不是素数，返回 0。
- 条件不满足，递归调用 gdbh(5, 10)。
第四次调用 gdbh(5, 10)：
- 检查 n > oushu / 2：5 > 10 / 2 成立，返回 0，结束递归。

最终输出

对于偶数 10，程序会输出：

10=3+7

类似地，程序会对 6 到 100 之间的所有偶数进行处理，并输出它们的哥德巴赫分解。

总结

它的核心思想是：

遍历所有可能的两个素数组合。
判断这些组合的和是否等于目标偶数。
打印出所有符合条件的分解形式。