查看: 2477|回复: 0

C语言经典算法实例5：验证哥德巴赫猜想

[复制链接]

字体大小: 正常放大

杨利霞

5273 主题	82 听众	17万积分

TA的每日心情

	开心 2021-8-11 17:59

签到天数: 17 天

[LV.4]偶尔看看III

网络挑战赛参赛者

自我介绍: 本人女，毕业于内蒙古科技大学，担任文职专业，毕业专业英语。

群组: 2018美赛大象算法课程

群组: 2018美赛护航培训课程

群组: 2019年数学中国站长建

群组: 2019年数据分析师课程

群组: 2018年大象老师国赛优

电梯直达

1^#

发表于 2022-9-15 12:12 |只看该作者 |倒序浏览

|招呼Ta 关注Ta

C语言经典算法实例5：验证哥德巴赫猜想
#「笔耕不辍」--生命不息，写作不止#
C语言经典算法实例5：验证哥德巴赫猜想
一、问题描述
1.1、什么是哥德巴赫猜想
1.2、什么是半素数
1.3、本文的问题描述
二、算法实例编译环境
三、算法实例实现过程
3.1、包含头文件
3.2、声明变量
3.３、输入一个大于 6 的偶数
3.4、对输入的数字进行哥德巴赫猜想的验证
3.5、判断输入的数字是否为素数。
3.6、对输入的数字进行哥德巴赫猜想的判断
3.7、判断数字1-100是否符合哥德巴赫猜想。
四、经典算法实例程序完整代码
4.1、main.h文件
4.2、main.c文件
五、总结

一、问题描述
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、本文的问题描述
验证哥德巴赫猜想
问题的描述
如下几点所示

任一充分大的偶数都可以表示成二个素数的和，或是一个素数和一个半素数的和。
偶数输入的为大于6的偶数。
对1-100之间的数字进行哥德巴赫猜想的验证。
程序采用函数模块化的思路。
二、算法实例编译环境
本文C语言经典算法实例的编译环境，使用的是集成开发环境：Visual Studio 2019

Visual Studio 2019官网链接如下

Visual Studio 2019官网链接

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

Visual Studio 2019默认安装Live Share代码协作服务。
帮助用户快速编写代码的新欢迎窗口、改进搜索功能、总体性能改进。
Visual Studio IntelliCode AI帮助。
更好的Python虚拟和Conda支持。
以及对包括WinForms和WPF在内的.NET Core 3.0项目支持等
三、算法实例实现过程
3.1、包含头文件
包含头文件代码如下所示

#pragma once

// 包含头文件
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <stdbool.h>
1
2
3
4
5
6
7
将要用到的Ｃ语言头文件包含近年来。
3.2、声明变量
声明变量代码如下所示

int a = 0;
1
声明了变量a。
作为输入的变量使用。
3.３、输入一个大于 6 的偶数
输入一个大于 6 的偶数代码如下所示

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

scanf("%d", &a);
printf("\n");
1
2
3
4
声明相关变量min, max，row, col, n;
3.4、对输入的数字进行哥德巴赫猜想的验证
对输入的数字进行哥德巴赫猜想的验证采用函数的方式进行编写。
对输入的数字进行哥德巴赫猜想的验证代码如下所示

进行哥德巴赫猜想的验证函数的声明。
/// <summary>
/// 对输入的数字进行哥德巴赫猜想的验证
/// </summary>
/// <param name="intNum">输入的数字</param>
/// <returns>blFlag</returns>
static bool ISGDBHArith(int intNum);
1
2
3
4
5
6
进行哥德巴赫猜想的验证函数的定义。
/// <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 型变量
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
对输入的数字进行哥德巴赫猜想的验证。
函数返回为bool类型的变量：blFlag。

3.5、判断输入的数字是否为素数。
判断输入的数字是否为素数，采用函数的方式编写。
判断输入的数字是否为素数，代码如下所示

判断输入的数字是否为素数的函数声明。
/// <summary>
/// 判断输入的数字是否为素数。
/// </summary>
/// <param name="intNum">输入的数字</param>
/// <returns>blFlag</returns>
static bool IsPrimeNumber(int intNum);
1
2
3
4
5
6
判断输入的数字是否为素数的函数定义。
/// <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 型变量
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
判断输入的数字是否为素数。
函数返回为bool类型的变量：blFlag。
按F5进行编译，调试结果如下所示。

可以正确的输出我们向数组中输入的数据。
3.6、对输入的数字进行哥德巴赫猜想的判断
对输入的数字进行哥德巴赫猜想的判断代码如下所示

if (blFlag)
{
      printf("\n%d：能写成两个素数的和,所以其符合哥德巴赫猜想。\n\n", a);
}
else
{
      printf("\n%d：不能写成两个素数的和,所以其不符合哥德巴赫猜想。\n\n", a);
}
1
2
3
4
5
6
7
8
如果输入的数字能写成两个素数的和，则符合哥德巴赫猜想。
如果输入的数字不能写成两个素数的和，则不符合哥德巴赫猜想。
按F5进行编译，调试结果如下所示。

3.7、判断数字1-100是否符合哥德巴赫猜想。
判断数字1-100是否符合哥德巴赫猜想采用函数编写的方式。
判断数字1-100是否符合哥德巴赫猜想代码如下所示。

判断数字1-100是否符合哥德巴赫猜想的函数声明。
/// <summary>
/// 判断数字1-100是否符合哥德巴赫猜想。
/// </summary>
void digitJudge();
1
2
3
4
判断数字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");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
使用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：能写成两个素数的和,所以其符合哥德巴赫猜想。

请按任意键继续. . .
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
四、经典算法实例程序完整代码
经典算法实例程序完整代码如下所示

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);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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 型变量
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
五、总结
本文的C语言经典算法实例：求二维数组最大最小值，要实现的目标如下

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

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

你的支持是对我最大的鼓励。
————————————————
版权声明：本文为CSDN博主「编程爱好者-阿新」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_47419053/article/details/126794077

zan