一、问题描述

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>

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

3.2、声明变量

声明变量代码如下所示

int a = 0;

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

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

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

  printf("输入一个大于 6 的偶数:");
    scanf("%d", &a);
    printf("\n");

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

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

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

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

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

/// <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 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、判断输入的数字是否为素数。

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

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

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

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

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

/// <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-100是否符合哥德巴赫猜想的函数声明。

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

判断数字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语言经典算法实例：求二维数组最大最小值，要实现的目标如下

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

文到这里就结束啦。

希望本文的C语言经典算法实例：验证哥德巴赫猜想。

能激发你对C语言以及算法学习的热爱。

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

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文件

五、总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景

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文件

五、总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景

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