[C++知识库]C语言经典算法实例5：验证哥德巴赫猜想

一、问题描述

1.1、什么是哥德巴赫猜想

哥德巴赫1742年在给欧拉的信中提出了以下猜想：任一大于2的整数都可写成三个质数之和 。但是哥德巴赫自己无法证明它，于是就写信请教赫赫有名的大数学家欧拉帮忙证明，但是一直到死，欧拉也无法证明。 因现今数学界已经不使用“1也是素数”这个约定，原初猜想的现代陈述为：任一大于5的整数都可写成三个质数之和。(n>5：当n为偶数，n=2+(n-2)，n-2也是偶数，可以分解为两个质数的和；当n为奇数，n=3+(n-3)，n-3也是偶数，可以分解为两个质数的和)欧拉在回信中也提出另一等价版本，即任一大于2的偶数都可写成两个质数之和。今日常见的猜想陈述为欧拉的版本。把命题"任一充分大的偶数都可以表示成为一个素因子个数不超过a个的数与另一个素因子不超过b个的数之和"记作"a+b"。1966年陈景润证明了"1+2"成立，即"任一充分大的偶数都可以表示成二个素数的和，或是一个素数和一个半素数的和"。

1.2、什么是半素数

• 什么是半素数

两个素数的乘积所得的自然数
若一个自然数可以表示成两个素数乘积的形式，这个自然数就叫做半素数（又名半质数、二次殆素数）。

• 例如下面的一些数字为半素数。

4，6，9，10，14，15，21，22，25，26，33，34，35，38，39，46，49，51，55，57，58，62，65，69，74，77，82，85，86，87，91，93，94，95，106，111，115，118，119，121，122，123，129，133，134，141，142.

1.3、本文的问题描述

验证哥德巴赫猜想
问题的描述
如下几点所示

1. 任一充分大的偶数都可以表示成二个素数的和，或是一个素数和一个半素数的和。
2. 偶数输入的为大于6的偶数。
3. 对1-100之间的数字进行哥德巴赫猜想的验证。
4. 程序采用函数模块化的思路。

二、算法实例编译环境

本文C语言经典算法实例的编译环境，使用的是集成开发环境：Visual Studio 2019

Visual Studio 2019官网链接如下

Visual Studio 2019官网链接

Visual Studio 2019集成的开发环境的特点有

1. Visual Studio 2019默认安装Live Share代码协作服务。
2. 帮助用户快速编写代码的新欢迎窗口、改进搜索功能、总体性能改进。
3. Visual Studio IntelliCode AI帮助。
4. 更好的Python虚拟和Conda支持。
5. 以及对包括WinForms和WPF在内的.NET Core 3.0项目支持等

三、算法实例实现过程

3.1、包含头文件

包含头文件 代码如下所示

#pragma once

// 包含头文件
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <stdbool.h>

• 将要用到的Ｃ语言头文件包含近年来。

3.2、声明变量

声明变量 代码如下所示

int a = 0;

• 声明了变量a。
• 作为输入的变量使用。

3.３、输入一个大于 6 的偶数

输入一个大于 6 的偶数 代码如下所示

	printf("输入一个大于 6 的偶数:");

    scanf("%d", &a);
    printf("\n");

• 声明相关变量min, max，row, col, n;

3.4、对输入的数字进行哥德巴赫猜想的验证

• 对输入的数字进行哥德巴赫猜想的验证采用函数的方式进行编写。

对输入的数字进行哥德巴赫猜想的验证 代码如下所示

1. 进行哥德巴赫猜想的验证函数的声明。

/// <summary>
/// 对输入的数字进行哥德巴赫猜想的验证
/// </summary>
/// <param name="intNum">输入的数字</param>
/// <returns>blFlag</returns>
static bool ISGDBHArith(int intNum);

2. 进行哥德巴赫猜想的验证函数的定义。

/// <summary>
/// 对输入的数字进行哥德巴赫猜想的验证
/// </summary>
/// <param name="intNum">输入的数字</param>
/// <returns>blFlag</returns>
static bool ISGDBHArith(int intNum)
{
    bool blFlag = false;							    // 标识是否符合哥德巴赫猜想 
    if (intNum % 2 == 0 && intNum > 6)			        // 对要判断的数字进行判断 
    {
        for (int i = 1; i <= intNum / 2; i++)
        {
            bool bl1 = IsPrimeNumber(i);			    // 判断i 是否为素数 
            bool bl2 = IsPrimeNumber(intNum - i);		// 判断 intNum-i 是否为素数 

            if (bl1 & bl2)
            {
                //输出等式 
                printf("%d = %d + %d\n", intNum, i, intNum - i);
                blFlag = true;
                // 符合哥德巴赫猜想 
            }
        }
    }

    return blFlag;							            // 返回bool 型变量 
}

• 对输入的数字进行哥德巴赫猜想的验证。
• 函数返回为bool类型的变量：blFlag。
  

3.5、判断输入的数字是否为素数。

• 判断输入的数字是否为素数，采用函数的方式编写。

判断输入的数字是否为素数，代码如下所示

1. 判断输入的数字是否为素数的函数声明。

/// <summary>
/// 判断输入的数字是否为素数。
/// </summary>
/// <param name="intNum">输入的数字</param>
/// <returns>blFlag</returns>
static bool IsPrimeNumber(int intNum);

2. 判断输入的数字是否为素数的函数定义。

/// <summary>
/// 判断输入的数字是否为素数。
/// </summary>
/// <param name="intNum">输入的数字</param>
/// <returns>blFlag</returns>
static bool IsPrimeNumber(int intNum)
{
    bool blFlag = true;						    // 标识是否是素数 

    if (intNum == 1 || intNum == 2)				// 判断输入的数字是否是 1 或者 2 
    {
        blFlag = true;						    // 为bool 类型变量赋值 
    }
    else
    {
        int sqr = (int)(sqrt((double)intNum));	// 对要判断的数字进行开方运算 

        for (int i = sqr; i >= 2; i--)			// 从开方后的数进行循环 
        {
            if (intNum % i == 0)				// 对要判断的数字和指定数字进行求余运算 
            {
                blFlag = false;				    // 如果余数为 0，说明不是素数 
            }
        }
    }

    return blFlag;							    // 返回bool 型变量 
}

• 判断输入的数字是否为素数。
• 函数返回为bool类型的变量：blFlag。

按F5进行编译，调试结果如下所示。

• 可以正确的输出我们向数组中输入的数据。

3.6、对输入的数字进行哥德巴赫猜想的判断

对输入的数字进行哥德巴赫猜想的判断 代码如下所示

	if (blFlag)
    {
        printf("\n%d：能写成两个素数的和,所以其符合哥德巴赫猜想。\n\n", a);
    }
    else
    {
        printf("\n%d：不能写成两个素数的和,所以其不符合哥德巴赫猜想。\n\n", a);
    }

• 如果输入的数字能写成两个素数的和，则符合哥德巴赫猜想。
• 如果输入的数字不能写成两个素数的和，则不符合哥德巴赫猜想。

按F5进行编译，调试结果如下所示。

3.7、判断数字1-100是否符合哥德巴赫猜想。

• 判断数字1-100是否符合哥德巴赫猜想采用函数编写的方式。

判断数字1-100是否符合哥德巴赫猜想 代码如下所示。

1. 判断数字1-100是否符合哥德巴赫猜想的函数声明。

 /// <summary>
/// 判断数字1-100是否符合哥德巴赫猜想。
/// </summary>
void digitJudge();

2. 判断数字1-100是否符合哥德巴赫猜想的函数定义。

/// <summary>
/// 判断数字1-100是否符合哥德巴赫猜想。
/// </summary>
void digitJudge()
{

    for (int i = 1; i <= 100; i++)
    {
        bool blFlag = ISGDBHArith(i);				        // 判断是否符合哥德巴赫猜想 

        if (blFlag)
        {
            printf("\n%d：能写成两个素数的和,所以其符合哥德巴赫猜想。\n\n", i);
        }
        else
        {
            printf("\n%d：不能写成两个素数的和,所以其不符合哥德巴赫猜想。\n\n", i);
        }

        printf("\n");
    }
}

• 使用for循环的方式。
• 判断数字1-100是否符合哥德巴赫猜想。

按F5进行编译，调试结果如下所示。

输入一个大于 6 的偶数:24

24 = 1 + 23
24 = 5 + 19
24 = 7 + 17
24 = 11 + 13

24：能写成两个素数的和,所以其符合哥德巴赫猜想。


1：不能写成两个素数的和,所以其不符合哥德巴赫猜想。



2：不能写成两个素数的和,所以其不符合哥德巴赫猜想。



3：不能写成两个素数的和,所以其不符合哥德巴赫猜想。



4：不能写成两个素数的和,所以其不符合哥德巴赫猜想。



5：不能写成两个素数的和,所以其不符合哥德巴赫猜想。



6：不能写成两个素数的和,所以其不符合哥德巴赫猜想。



7：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


8 = 1 + 7
8 = 3 + 5

8：能写成两个素数的和,所以其符合哥德巴赫猜想。



9：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


10 = 3 + 7
10 = 5 + 5

10：能写成两个素数的和,所以其符合哥德巴赫猜想。



11：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


12 = 1 + 11
12 = 5 + 7

12：能写成两个素数的和,所以其符合哥德巴赫猜想。



13：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


14 = 1 + 13
14 = 3 + 11
14 = 7 + 7

14：能写成两个素数的和,所以其符合哥德巴赫猜想。



15：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


16 = 3 + 13
16 = 5 + 11

16：能写成两个素数的和,所以其符合哥德巴赫猜想。



17：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


18 = 1 + 17
18 = 5 + 13
18 = 7 + 11

18：能写成两个素数的和,所以其符合哥德巴赫猜想。



19：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


20 = 1 + 19
20 = 3 + 17
20 = 7 + 13

20：能写成两个素数的和,所以其符合哥德巴赫猜想。



21：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


22 = 3 + 19
22 = 5 + 17
22 = 11 + 11

22：能写成两个素数的和,所以其符合哥德巴赫猜想。



23：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


24 = 1 + 23
24 = 5 + 19
24 = 7 + 17
24 = 11 + 13

24：能写成两个素数的和,所以其符合哥德巴赫猜想。



25：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


26 = 3 + 23
26 = 7 + 19
26 = 13 + 13

26：能写成两个素数的和,所以其符合哥德巴赫猜想。



27：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


28 = 5 + 23
28 = 11 + 17

28：能写成两个素数的和,所以其符合哥德巴赫猜想。



29：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


30 = 1 + 29
30 = 7 + 23
30 = 11 + 19
30 = 13 + 17

30：能写成两个素数的和,所以其符合哥德巴赫猜想。



31：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


32 = 1 + 31
32 = 3 + 29
32 = 13 + 19

32：能写成两个素数的和,所以其符合哥德巴赫猜想。



33：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


34 = 3 + 31
34 = 5 + 29
34 = 11 + 23
34 = 17 + 17

34：能写成两个素数的和,所以其符合哥德巴赫猜想。



35：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


36 = 5 + 31
36 = 7 + 29
36 = 13 + 23
36 = 17 + 19

36：能写成两个素数的和,所以其符合哥德巴赫猜想。



37：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


38 = 1 + 37
38 = 7 + 31
38 = 19 + 19

38：能写成两个素数的和,所以其符合哥德巴赫猜想。



39：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


40 = 3 + 37
40 = 11 + 29
40 = 17 + 23

40：能写成两个素数的和,所以其符合哥德巴赫猜想。



41：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


42 = 1 + 41
42 = 5 + 37
42 = 11 + 31
42 = 13 + 29
42 = 19 + 23

42：能写成两个素数的和,所以其符合哥德巴赫猜想。



43：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


44 = 1 + 43
44 = 3 + 41
44 = 7 + 37
44 = 13 + 31

44：能写成两个素数的和,所以其符合哥德巴赫猜想。



45：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


46 = 3 + 43
46 = 5 + 41
46 = 17 + 29
46 = 23 + 23

46：能写成两个素数的和,所以其符合哥德巴赫猜想。



47：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


48 = 1 + 47
48 = 5 + 43
48 = 7 + 41
48 = 11 + 37
48 = 17 + 31
48 = 19 + 29

48：能写成两个素数的和,所以其符合哥德巴赫猜想。



49：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


50 = 3 + 47
50 = 7 + 43
50 = 13 + 37
50 = 19 + 31

50：能写成两个素数的和,所以其符合哥德巴赫猜想。



51：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


52 = 5 + 47
52 = 11 + 41
52 = 23 + 29

52：能写成两个素数的和,所以其符合哥德巴赫猜想。



53：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


54 = 1 + 53
54 = 7 + 47
54 = 11 + 43
54 = 13 + 41
54 = 17 + 37
54 = 23 + 31

54：能写成两个素数的和,所以其符合哥德巴赫猜想。



55：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


56 = 3 + 53
56 = 13 + 43
56 = 19 + 37

56：能写成两个素数的和,所以其符合哥德巴赫猜想。



57：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


58 = 5 + 53
58 = 11 + 47
58 = 17 + 41
58 = 29 + 29

58：能写成两个素数的和,所以其符合哥德巴赫猜想。



59：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


60 = 1 + 59
60 = 7 + 53
60 = 13 + 47
60 = 17 + 43
60 = 19 + 41
60 = 23 + 37
60 = 29 + 31

60：能写成两个素数的和,所以其符合哥德巴赫猜想。



61：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


62 = 1 + 61
62 = 3 + 59
62 = 19 + 43
62 = 31 + 31

62：能写成两个素数的和,所以其符合哥德巴赫猜想。



63：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


64 = 3 + 61
64 = 5 + 59
64 = 11 + 53
64 = 17 + 47
64 = 23 + 41

64：能写成两个素数的和,所以其符合哥德巴赫猜想。



65：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


66 = 5 + 61
66 = 7 + 59
66 = 13 + 53
66 = 19 + 47
66 = 23 + 43
66 = 29 + 37

66：能写成两个素数的和,所以其符合哥德巴赫猜想。



67：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


68 = 1 + 67
68 = 7 + 61
68 = 31 + 37

68：能写成两个素数的和,所以其符合哥德巴赫猜想。



69：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


70 = 3 + 67
70 = 11 + 59
70 = 17 + 53
70 = 23 + 47
70 = 29 + 41

70：能写成两个素数的和,所以其符合哥德巴赫猜想。



71：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


72 = 1 + 71
72 = 5 + 67
72 = 11 + 61
72 = 13 + 59
72 = 19 + 53
72 = 29 + 43
72 = 31 + 41

72：能写成两个素数的和,所以其符合哥德巴赫猜想。



73：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


74 = 1 + 73
74 = 3 + 71
74 = 7 + 67
74 = 13 + 61
74 = 31 + 43
74 = 37 + 37

74：能写成两个素数的和,所以其符合哥德巴赫猜想。



75：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


76 = 3 + 73
76 = 5 + 71
76 = 17 + 59
76 = 23 + 53
76 = 29 + 47

76：能写成两个素数的和,所以其符合哥德巴赫猜想。



77：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


78 = 5 + 73
78 = 7 + 71
78 = 11 + 67
78 = 17 + 61
78 = 19 + 59
78 = 31 + 47
78 = 37 + 41

78：能写成两个素数的和,所以其符合哥德巴赫猜想。



79：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


80 = 1 + 79
80 = 7 + 73
80 = 13 + 67
80 = 19 + 61
80 = 37 + 43

80：能写成两个素数的和,所以其符合哥德巴赫猜想。



81：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


82 = 3 + 79
82 = 11 + 71
82 = 23 + 59
82 = 29 + 53
82 = 41 + 41

82：能写成两个素数的和,所以其符合哥德巴赫猜想。



83：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


84 = 1 + 83
84 = 5 + 79
84 = 11 + 73
84 = 13 + 71
84 = 17 + 67
84 = 23 + 61
84 = 31 + 53
84 = 37 + 47
84 = 41 + 43

84：能写成两个素数的和,所以其符合哥德巴赫猜想。



85：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


86 = 3 + 83
86 = 7 + 79
86 = 13 + 73
86 = 19 + 67
86 = 43 + 43

86：能写成两个素数的和,所以其符合哥德巴赫猜想。



87：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


88 = 5 + 83
88 = 17 + 71
88 = 29 + 59
88 = 41 + 47

88：能写成两个素数的和,所以其符合哥德巴赫猜想。



89：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


90 = 1 + 89
90 = 7 + 83
90 = 11 + 79
90 = 17 + 73
90 = 19 + 71
90 = 23 + 67
90 = 29 + 61
90 = 31 + 59
90 = 37 + 53
90 = 43 + 47

90：能写成两个素数的和,所以其符合哥德巴赫猜想。



91：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


92 = 3 + 89
92 = 13 + 79
92 = 19 + 73
92 = 31 + 61

92：能写成两个素数的和,所以其符合哥德巴赫猜想。



93：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


94 = 5 + 89
94 = 11 + 83
94 = 23 + 71
94 = 41 + 53
94 = 47 + 47

94：能写成两个素数的和,所以其符合哥德巴赫猜想。



95：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


96 = 7 + 89
96 = 13 + 83
96 = 17 + 79
96 = 23 + 73
96 = 29 + 67
96 = 37 + 59
96 = 43 + 53

96：能写成两个素数的和,所以其符合哥德巴赫猜想。



97：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


98 = 1 + 97
98 = 19 + 79
98 = 31 + 67
98 = 37 + 61

98：能写成两个素数的和,所以其符合哥德巴赫猜想。



99：不能写成两个素数的和,所以其不符合哥德巴赫猜想。


100 = 3 + 97
100 = 11 + 89
100 = 17 + 83
100 = 29 + 71
100 = 41 + 59
100 = 47 + 53

100：能写成两个素数的和,所以其符合哥德巴赫猜想。


请按任意键继续. . .

四、经典算法实例程序 完整代码

经典算法实例程序完整代码如下所示

4.1、main.h文件

#pragma once

// 包含头文件
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <stdbool.h>

/// <summary>
/// 判断数字1-100是否符合哥德巴赫猜想。
/// </summary>
void digitJudge();

/// <summary>
/// 对输入的数字进行哥德巴赫猜想的验证
/// </summary>
/// <param name="intNum">输入的数字</param>
/// <returns>blFlag</returns>
static bool ISGDBHArith(int intNum);


/// <summary>
/// 判断输入的数字是否为素数。
/// </summary>
/// <param name="intNum">输入的数字</param>
/// <returns>blFlag</returns>
static bool IsPrimeNumber(int intNum);

4.2、main.c文件

#define _CRT_SECURE_NO_WARNINGS

#include "Main.h"


/// <summary>
/// 主函数
/// </summary>
/// <returns>返回0</returns>
int main()
{
    system("color 3E");

    int a = 0;

    printf("输入一个大于 6 的偶数:");

    scanf("%d", &a);
    printf("\n");

    bool blFlag = ISGDBHArith(a);				        // 判断是否符合哥德巴赫猜想 

    if (blFlag)
    {
        printf("\n%d：能写成两个素数的和,所以其符合哥德巴赫猜想。\n\n", a);
    }
    else
    {
        printf("\n%d：不能写成两个素数的和,所以其不符合哥德巴赫猜想。\n\n", a);
    }

    digitJudge();

    system("pause");
    return 0;
}

/// <summary>
/// 判断数字1-100是否符合哥德巴赫猜想。
/// </summary>
void digitJudge()
{

    for (int i = 1; i <= 100; i++)
    {
        bool blFlag = ISGDBHArith(i);				        // 判断是否符合哥德巴赫猜想 

        if (blFlag)
        {
            printf("\n%d：能写成两个素数的和,所以其符合哥德巴赫猜想。\n\n", i);
        }
        else
        {
            printf("\n%d：不能写成两个素数的和,所以其不符合哥德巴赫猜想。\n\n", i);
        }

        printf("\n");
    }
}

/// <summary>
/// 对输入的数字进行哥德巴赫猜想的验证
/// </summary>
/// <param name="intNum">输入的数字</param>
/// <returns>blFlag</returns>
static bool ISGDBHArith(int intNum)
{
    bool blFlag = false;							    // 标识是否符合哥德巴赫猜想 
    if (intNum % 2 == 0 && intNum > 6)			        // 对要判断的数字进行判断 
    {
        for (int i = 1; i <= intNum / 2; i++)
        {
            bool bl1 = IsPrimeNumber(i);			    // 判断i 是否为素数 
            bool bl2 = IsPrimeNumber(intNum - i);		// 判断 intNum-i 是否为素数 

            if (bl1 & bl2)
            {
                //输出等式 
                printf("%d = %d + %d\n", intNum, i, intNum - i);
                blFlag = true;
                // 符合哥德巴赫猜想 
            }
        }
    }

    return blFlag;							            // 返回bool 型变量 
}


/// <summary>
/// 判断输入的数字是否为素数。
/// </summary>
/// <param name="intNum">输入的数字</param>
/// <returns>blFlag</returns>
static bool IsPrimeNumber(int intNum)
{
    bool blFlag = true;						    // 标识是否是素数 

    if (intNum == 1 || intNum == 2)				// 判断输入的数字是否是 1 或者 2 
    {
        blFlag = true;						    // 为bool 类型变量赋值 
    }
    else
    {
        int sqr = (int)(sqrt((double)intNum));	// 对要判断的数字进行开方运算 

        for (int i = sqr; i >= 2; i--)			// 从开方后的数进行循环 
        {
            if (intNum % i == 0)				// 对要判断的数字和指定数字进行求余运算 
            {
                blFlag = false;				    // 如果余数为 0，说明不是素数 
            }
        }
    }

    return blFlag;							    // 返回bool 型变量 
}

五、总结

本文的C语言经典算法实例：求二维数组最大最小值，要实现的目标如下

1. 任一充分大的偶数都可以表示成二个素数的和，或是一个素数和一个半素数的和。
2. 偶数输入的为大于6的偶数。
3. 对1-100之间的数字进行哥德巴赫猜想的验证。
4. 程序采用函数模块化的思路。

文到这里就结束啦。
希望本文的C语言经典算法实例：验证哥德巴赫猜想。
能激发你对C语言以及算法学习的热爱。

• 你的支持是对我最大的鼓励。