判断质数的5个C语言程序
c语言求素数最快方法
c语言求素数最快方法摘要：1.引言2.最快方法：埃拉托斯特尼筛法（Sieve of Eratosthenes）3.算法原理4.C语言实现5.代码解析6.性能测试与优化7.结论正文：**引言**在计算机科学和编程领域，寻找素数是一种常见的任务。
素数是指大于1的自然数中，除了1和它本身以外，不能被其他自然数整除的数。
求解素数问题有助于理解数论、密码学等领域。
本文将介绍求解素数的最快方法——埃拉托斯特尼筛法（Sieve of Eratosthenes）及其C语言实现。
**最快方法：埃拉托斯特尼筛法（Sieve of Eratosthenes）**埃拉托斯特尼筛法是一种基于二维数组的算法，用于找出小于等于上限的素数。
该算法利用了素数的性质：如果一个数是素数，那么它的平方模小于等于上限的数也是素数。
通过不断标记数组中的素数，最终得到小于等于上限的素数。
**算法原理**1.创建一个二维数组，用于存储小于等于上限的数。
2.初始化数组中的所有元素为1，表示都是素数。
3.从2开始，遍历数组，将数组中的所有素数两两相乘，得到的结果大于上限的，将其对应的元素标记为0，表示该数不是素数。
4.重复步骤3，直到数组中的所有元素都被标记或遍历到上限。
**C语言实现**以下是一个简单的C语言实现：```c#include <stdio.h>#include <stdbool.h>void sieve_of_eratosthenes(int limit) {bool *prime = (bool *)malloc((limit + 1) * sizeof(bool));for (int i = 0; i <= limit; i++) {prime[i] = true;}for (int p = 2; p * p <= limit; p++) {if (prime[p]) {for (int i = p * p; i <= limit; i += p) {prime[i] = false;}}}for (int i = 2; i <= limit; i++) {if (prime[i]) {printf("%d ", i);}}free(prime);}int main() {int limit;printf("请输入一个上限：");scanf("%d", &limit);sieve_of_eratosthenes(limit);return 0;}```**代码解析**1.首先，我们需要一个布尔数组来存储小于等于上限的数是否为素数。
统计素数并求和c语言pta
统计素数并求和c语言pta在计算机科学中，素数是一个非常重要的概念。
所谓素数，是指只能被1和自身整除的自然数。
在数学领域，素数也被称为质数。
素数在密码学、数据加密等领域中扮演着重要的角色。
其特性使得素数成为一种安全的加密算法基础。
因此，对于计算机科学专业的学生来说，掌握素数的性质和求解方法非常关键。
C语言是一个广泛应用于编程和算法实现的语言，对于计算素数也提供了很多实用的方法。
下面将介绍一个简单但高效的算法，通过C语言统计并求和素数。
首先，我们需要了解C语言中常用的数据类型和循环结构。
对于整数类型，我们可以选择使用int型来表示自然数。
而循环结构，比如for循环，可以用来遍历指定范围内的数字。
接下来，我们需要实现一个函数来判断一个数字是否是素数。
一个数字n是素数，当且仅当它不能被2到sqrt(n)之间的任意整数整除。
我们可以通过for循环来判断n是否能被这个范围内的数字整除，如果整除则不是素数，否则是素数。
在函数中，我们需要使用一个标志变量来判断是否有数字可以整除n。
当有数字可以整除n时，将标志变量设置为0，表示不是素数。
如果没有数字可以整除n，则标志变量保持为1，表示是素数。
接着，我们可以编写一个主函数来实现统计和求和素数的功能。
我们需要定义一个变量sum，用于记录所有素数的和。
利用for循环，我们可以遍历指定范围内的数字，并调用判断素数的函数来判断每个数字是否是素数。
如果是素数，将sum加上该素数的值。
最后，在控制台输出sum的值，即为统计并求和素数的结果。
综上所述，通过使用C语言中的数据类型和循环结构，我们可以简单而高效地统计素数并求和。
对于计算机科学专业的学生来说，通过掌握这种方法，可以提高解决问题的能力和编程技巧。
同时，对于密码学和数据加密等领域的研究人员来说，了解素数的性质和应用是非常重要的。
希望通过本文的介绍，读者能够更好地理解素数的概念和求解方法，以及在C语言中实现统计素数并求和的过程。
分解质因数c语言
分解质因数c语言
c语言是一种广泛使用的计算机编程语言，它拥有强大的表达能力、可读性高的语法以及简易的程序结构。
本文将介绍什么是质因数，以及如何使用c语言来分解质因数。
二、质因数
质因数是指一个整数可以被质数整除，其结果正好是这个整数本身，而非1。
也被称为因子，也就是说，一个数如果可以被归结为若干个质数的乘积，则这些质数就是这个数的质因数。
例如，12的质因数为2和3，其质因数式就是12=2*3。
三、如何使用c语言分解质因数
1.用循环结构，找出比目标数小的质数。
要想知道一个数是否是质数，可以利用for循环实现不断减小i，当i到达1时，若其它数都不能被整除，则此时的i为该数的质因数。
如果能被整除，则i不是该数的质因数，可以继续循环，直到找到质因数为止。
2.穷举法给出质因数。
定义一个变量j，用来表示目标数的质因数，可以使用for循环从1开始一直到目标数为止，在循环过程中如果满足质数的条件，则j就为质因数并把它保存下来，重复上述步骤，直到找到目标数的所有质因数，最终结果就是所有质因数的乘积。
3.得到的质因数输出到屏幕上。
最后，使用printf函数把质因数输出到屏幕上，并用循环来显
示相应的结果，这样用户就可以准确的看到质因数分解的结果，更容易理解其含义。
四、总结
本文主要介绍了什么是质因数，以及如何使用C语言分解质因数。
要分解质因数，需要运用到循环结构和穷举法，并且要有良好的程序语法和编程技巧，才能在短时间内准确的得出结果。
筛选法求素数c语言
筛选法求素数c语言一、什么是素数？素数，又称质数，是指在大于1的自然数中，除了1和它本身以外，不能被其他自然数整除的数。
比如2、3、5、7、11等都是素数。
二、为什么要求素数？在计算机科学中，素数有着重要的应用。
比如在加密算法中，RSA算法就是基于大质数的分解来实现加密和解密的。
此外，在计算机图形学中也常常用到素数。
三、筛选法求素数筛选法求素数是一种简单而有效的方法。
它的基本思想是：先把从2开始的各个自然数列出来，然后按照从小到大的顺序对每个未标记过的最小质数p进行标记，并把p的倍数标记成合数。
重复这个过程直到所有数字都被标记。
具体实现上可以使用一个布尔数组isPrime[]来表示每个数字是否为质数。
初始时将所有元素赋值为true（即都认为是质数），然后从2开始遍历数组，如果当前元素isPrime[i]为true，则说明i是一个质数，并将i的倍数isPrime[i*j]（j=2,3,4...）全部标记成false（即合数）。
这样遍历完整个数组后，isPrime[]为true的元素就是所有的质数。
四、C语言代码实现下面是一个基于筛选法求素数的C语言代码实现：```c#include <stdio.h>#include <stdlib.h>#include <stdbool.h>void sieveOfEratosthenes(int n) {bool isPrime[n+1];for (int i = 2; i <= n; i++) {isPrime[i] = true;}for (int i = 2; i*i <= n; i++) {if (isPrime[i]) {for (int j = i*i; j <= n; j += i) {isPrime[j] = false;}}}printf("The prime numbers between 2 and %d are:\n", n);for (int i = 2; i <= n; i++) {if (isPrime[i]) {printf("%d ", i);}}}int main() {int n;printf("Enter a number: ");scanf("%d", &n);sieveOfEratosthenes(n);return 0;}```五、代码解析首先定义了一个函数sieveOfEratosthenes，它的参数n表示要求解的范围。
prime在c语言中的意思
prime在c语言中的意思
在C语言中，prime通常指质数。
质数是指只能被1和它本身整除的正整数，比如2、3、5、7等。
而非质数则被称为合数。
在程序设计中，判断一个数字是否为质数是一个常见的问题。
通常使用循环来判断一个数字是否能被小于它本身的所有正整数整除，如果都不能，则该数字为质数，否则为合数。
以下是一个简单的C语言程序示例：
```
#include <stdio.h>
int main() {
int num, i, flag = 0;
printf("请输入一个正整数：");
scanf("%d", &num);
for (i = 2; i <= num / 2; ++i) {
if (num % i == 0) {
flag = 1;
break;
}
}
if (flag == 0)
printf("%d是质数", num);
else
printf("%d不是质数", num);
return 0;
}
```
以上程序通过循环来判断输入的数字是否为质数，并输出相应的结果。
在实际应用中，判断质数还有更高效的算法，如埃拉托色尼筛法等。
C语言程序开发经典实例
main(){int i,j,k;for(i=0;i<=3;i++){for(j=0;j<=2-i;j++)printf(" ");for(k=0;k<=2*i;k++)printf("*");printf("\n");}for(i=0;i<=2;i++){for(j=0;j<=i;j++)printf(" ");for(k=0;k<=4-2*i;k++)printf("*");printf("\n");}}==============================================================【程序24】题目：有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13...求出这个数列的前20项之和。
1.程序分析：请抓住分子与分母的变化规律。
2.程序源代码：main(){int n,t,number=20;float a=2,b=1,s=0;for(n=1;n<=number;n++){s=s+a/b;t=a;a=a+b;b=t;/*这部分是程序的关键，请读者猜猜t的作用*/}printf("sum is %9.6f\n",s);for(i=0;i<5;i++)printf("\40:%d!=%d\n",i,fact(i));}int fact(j)int j;{int sum;if(j==0)sum=1;elsesum=j*fact(j-1);return sum;}==============================================================【程序27】题目：利用递归函数调用方式，将所输入的5个字符，以相反顺序打印出来。
c语言质数判断
{
printf("YES\n");
}
else
{
printf("NO\n");
}
system("PAUSE");
return 0;
}
4. 一维数组 int s[10], 任意赋10个值。 要求用冒泡法进行排序.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
int num,j;
printf("请输入一个整数:");
scanf("%d",&num);
boo1 flag=true;
for(j=2;j<num;j++)
printf("2.服务:\n");
printf("3.取卡:\n");
printf("请选择1-3:");
scanf(" %d",&choice);
switch(choice){
case 3:
printf("取卡\n");
for(j=0;j<num;j++)
{
if(num%j==0)
{
printf("NO\n");
break;
}else
{
printf("Yes\n");
#include <stdlib.h>
初学编程100个代码大全c语言
初学编程100个代码大全c语言当初学编程时，了解一些常见的代码示例是非常有帮助的。
以下是一些常见的C语言代码示例，总共100个，供你参考：1. Hello World程序：c.#include <stdio.h>。
int main() {。
printf("Hello, World!\n");return 0;}。
2. 计算两个数的和：#include <stdio.h>。
int main() {。
int num1, num2, sum;printf("Enter two numbers: "); scanf("%d %d", &num1, &num2); sum = num1 + num2;printf("Sum = %d\n", sum);return 0;}。
3. 判断一个数是奇数还是偶数：#include <stdio.h>。
int main() {。
int num;printf("Enter a number: ");scanf("%d", &num);if (num % 2 == 0) {。
printf("%d is even.\n", num); } else {。
printf("%d is odd.\n", num); }。
return 0;}。
4. 判断一个数是正数、负数还是零：c.#include <stdio.h>。
int main() {。
int num;printf("Enter a number: ");scanf("%d", &num);if (num > 0) {。
printf("%d is positive.\n", num);} else if (num < 0) {。
深入分析C语言分解质因数的实现方法
首先来看一个最简单的C语言实现质因数分解的列子：?123 4 5 6 7 8 9101112131415 #include <stdio.h>voidmain( ){intdata, i = 2; scanf("%d", &data);while(data > 1){if(data % i == 0){printf("%d ", i);data /= i;}elsei++;}}原理&&方法把一个合数分解为若干个质因数的乘积的形式，即求质因数的过程叫做分解质因数，分解质因数只针对合数求一个数分解质因数，要从最小的质数除起，一直除到结果为质数为止。
分解质因数的算式的叫短除法，和除法的性质差不多，还可以用来求多个个数的公因式：以24为例：2 -- 242 -- 122 -- 63 （3是质数，结束）得出24 = 2 × 2 × 2 × 3 = 2^3 * 3代码可先用素数筛选法，筛选出符合条件的质因数，然后for循环遍历即可，通过一道题目来show 一下这部分代码题目1题目描述：求正整数N(N>1)的质因数的个数。
相同的质因数需要重复计算。
如120=2*2*2*3*5，共有5个质因数。
输入：可能有多组测试数据，每组测试数据的输入是一个正整数N，(1<N<10^9)。
输出：对于每组数据，输出N的质因数的个数。
样例输入：120样例输出：5提示：注意：1不是N的质因数；若N为质数，N是N的质因数。
ac代码?1 2 3 4 5 6 7 8 910111213141516#include <stdio.h>intmain(){intn, count, i;while(scanf("%d", &n) != EOF) {count = 0;for(i = 2; i * i<= n; i ++) {if(n % i == 0) {while(n % i == 0) {count ++;n /= i;}}}if(n > 1) {count ++;}printf("%d\n", count);若a存在质因数px，则b必也存在该质因数，且该素因数在b中对应的幂指数必不小于在a中的幂指数另b = n!, a^k = p1^ke1 * p2^ke2 * ... * pn^ken，因此我们需要确定最大的非负整数k 即可。
0~n范围内的质数判断c语言__解释说明
0~n范围内的质数判断c语言解释说明1. 引言1.1 概述在计算机科学和数学领域中，质数判断是一项经典而重要的任务。
质数是指除了1和自身外没有其他因子的自然数。
而质数判断就是用于确定一个给定数字是否为质数的过程。
本篇长文将详细讨论如何使用C语言来实现质数判断算法。
我们将介绍质数的定义和特性，以及不同分类的质数判断算法。
同时，我们也将探讨在实际应用中质数判断的重要性，并提供一些优化算法效率的技巧和方法。
1.2 文章结构本文共分为五个部分：引言、质数判断的原理及应用、C语言实现质数判断算法、实例演示以及结论。
每个部分都包含若干小节，通过这种结构化的方式，读者可以更好地理解文章内容，在阅读过程中能够轻松跳转到感兴趣的章节。
1.3 目的本文旨在系统地介绍如何使用C语言来实现0~n范围内的质数判断算法。
通过对不同算法思路和实现方法的详细解析，读者可以更深入地理解质数相关概念和算法。
同时，本文还将通过实例演示，帮助读者掌握如何设计和分析质数判断程序的运行结果，并提供进一步优化算法的思路。
通过阅读本文，读者将能够理解质数判断的原理和应用、掌握C语言实现质数判断算法的具体方法、了解不同范围下算法执行时间和空间复杂度等指标变化情况，以及对C语言质数判断算法进行评价和展望其未来发展前景。
在这些基础上，读者可以在实际开发中灵活应用质数判断算法，并根据需求进行优化。
2. 质数判断的原理及应用:2.1 质数的定义与特性:质数是指只能被1和自身整除的整数，即除了1和本身外没有其他因数的数字。
质数的特性包括：只有两个约数（1和自身）、大于1、不能被其他数字整除。
2.2 质数判断算法的分类:常见的质数判断算法可以分为试除法和素数筛法两种：- 试除法是一种简单直观的方法，通过遍历范围内所有可能的因子来判断一个数字是否为质数。
具体步骤包括从2开始依次试除，若存在能整除该数字且不等于它本身的因子，则该数字不是质数；反之则为质数。
- 素数筛法又称作埃氏筛法，它使用了排除法来快速筛选出指定范围内所有的质数。
C语言求质数最好的算法
试编写一个程序，找出2->N之间的所有质数。
希望用尽可能快的方法实现。
【问题分析】：这个问题可以有两种解法：一种是用“筛子法”，另一种是从2->N检查，找出质数。
先来简单介绍一下“筛法”，求2~20的质数，它的做法是先把2~20这些数一字排开：2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20先取出数组中最小的数，是2，则判断2是质数，把后面2的倍数全部删掉。
2 |3 5 7 9 11 13 15 17 19接下来的最小数是3，取出，再删掉3的倍数2 3 | 5 7 11 13 17 19一直这样下去，直到结束。
筛法求质数的问题时，非质数的数据有很多是重复的。
例如，如果有一个数3×7×17×23，那么在删除3的倍数时会删到它，删7、17、23时同样也会删到它。
有一种“线性筛法”，可以安排删除的次序，使得每一个非质数都只被删除一次。
从而提高效率。
因为“筛法”不是我要介绍的重点，所以就不介绍了。
现在我来介绍第二种方法。
用这种方法，最先想到的就是让从2~N逐一检查。
如果是就显示出来，如果不是，就检查下一个。
这是正确的做法，但效率却不高。
当然，2是质数，那么2的倍数就不是质数，如果令i从2到N，就很冤枉地测试了4、6、8……这些数？所以第一点改建就是只测试2与所有的奇数就足够了。
同理，3是质数，但6、9、12……这些3的倍数却不是，因此，如果能够把2与3的倍数跳过去而不测试，任意连续的6个数中，就只会测试2个而已。
以6n,6n+1,6n+2,6n+3,6n+4,6n+5为例，6n,6n+2,6n+4是偶数，又6n+3是3的倍数，所以如果2与3的倍数都不理会，只要测试的数就只留下6n+1和6n+5而已了，因而工作量只是前面想法的2/6=1/3，应该用这个方法编程。
还有个问题，就是如果判断一个数i是否为素数。
按素数的定义，也就是只有1与本身可以整除，所以可以用2~i-1去除i，如果都除不尽，i就是素数。
C语言——判断一个数是否为质数素数
C语⾔——判断⼀个数是否为质数素数定义：约数只有1和本⾝的整数称为质数，或称素数。
计算机或者相关专业，基本上⼤⼀新⽣开始学编程都会接触的⼀个问题就是判断质数，下⾯分享⼏个判断⽅法，从普通到⾼效。
1）直观判断法最直观的⽅法，根据定义，因为质数除了1和本⾝之外没有其他约数，所以判断n是否为质数，根据定义直接判断从2到n-1是否存在n的约数即可。
C++代码如下：bool isPrime_1( int num ){int tmp =num- 1;for(int i= 2;i <=tmp; i++)if(num %i== 0)return 0 ;return 1 ;}2)直观判断法改进上述判断⽅法，明显存在效率极低的问题。
对于每个数n，其实并不需要从2判断到n-1，我们知道，⼀个数若可以进⾏因数分解，那么分解时得到的两个数⼀定是⼀个⼩于等于sqrt(n)，⼀个⼤于等于sqrt(n)，据此，上述代码中并不需要遍历到n-1，遍历到sqrt(n)即可，因为若sqrt(n)左侧找不到约数，那么右侧也⼀定找不到约数。
C++代码如下：1. bool isPrime_2( int num )2. {3. int tmp =sqrt( num);4. for(int i= 2;i <=tmp; i++)5. if(num %i== 0)6. return 0 ;7. return 1 ;8. }3）另⼀种⽅法⽅法（2）应该是最常见的判断算法了，时间复杂度O(sqrt(n))，速度上⽐⽅法（1）的O(n)快得多。
最近在⽹上偶然看到另⼀种更⾼效的⽅法，暂且称为⽅法（3）吧，由于找不到原始的出处，这⾥就不贴出链接了，如果有原创者看到，烦请联系我，必定补上版权引⽤。
下⾯讲⼀下这种更快速的判断⽅法；⾸先看⼀个关于质数分布的规律：⼤于等于5的质数⼀定和6的倍数相邻。
例如5和7，11和13,17和19等等；证明：令x≥1，将⼤于等于5的⾃然数表⽰如下：······ 6x-1，6x，6x+1，6x+2，6x+3，6x+4，6x+5，6(x+1），6(x+1)+1 ······可以看到，不在6的倍数两侧，即6x两侧的数为6x+2，6x+3，6x+4，由于2(3x+1)，3(2x+1)，2(3x+2)，所以它们⼀定不是素数，再除去6x本⾝，显然，素数要出现只可能出现在6x的相邻两侧。
c语言源代码
c语言源代码在计算机科学领域，C语言是一种被广泛应用的程序设计语言，它以其简洁、高效和可移植性而闻名。
本文将提供一些C语言的源代码示例，帮助读者更好地理解和应用这门编程语言。
1. Hello World程序#include <stdio.h>int main() {printf("Hello, World!");return 0;}上述代码是C语言中经典的Hello World程序。
它使用了stdio.h头文件，其中包含了用于输入输出的函数。
main()函数是程序的入口点，它执行printf函数并打印出"Hello, World!"的字符串。
最后，return语句表示程序正常结束。
2. 计算两个数的和#include <stdio.h>int main() {int num1, num2, sum;printf("请输入两个整数：");scanf("%d %d", &num1, &num2);sum = num1 + num2;printf("两个数的和为：%d", sum);return 0;}以上代码展示了如何用C语言编写一个简单的计算两个数的和的程序。
通过使用scanf函数，用户可以在程序运行时输入两个整数。
程序将这两个数相加，并使用printf函数打印出结果。
3. 判断一个数是否为质数#include <stdio.h>int main() {int num, i, isPrime = 1;printf("请输入一个正整数：");scanf("%d", &num);for (i = 2; i <= num / 2; ++i) {if (num % i == 0) {isPrime = 0;break;}}if (isPrime)printf("%d是质数", num);elseprintf("%d不是质数", num);return 0;}上述代码展示了如何用C语言编写一个判断一个数是否为质数的程序。
验证哥德巴赫猜想的c语言程序
验证哥德巴赫猜想的c语言程序哥德巴赫猜想是数学上的一个经典问题，即任何一个大于2的偶数都可以表示成两个质数之和。
虽然至今没有人证明其正确性，但已经有很多人给出了证明，并且也有很多人使用计算机程序来验证它。
下面是一个用C语言编写的程序，用于验证哥德巴赫猜想。
程序思路：1.定义一个函数is_prime()，用于判断一个数是否为质数。
2.定义一个函数verify_goldbach()，用于验证哥德巴赫猜想。
3.主程序中，输入一个大于2的偶数n，调用verify_goldbach()函数进行验证，并输出结果。
程序代码：#include <stdio.h>#include <stdbool.h>bool is_prime(int n){int i;for(i=2;i<n;i++){if(n%i==0){return false;}}return true;}void verify_goldbach(int n){int i,j;for(i=2;i<=n/2;i++){if(is_prime(i)){for(j=n-i;j>=i;j--){if(is_prime(j)){if(i+j==n){printf('%d=%d+%d',n,i,j);return;}}}}}printf('验证失败！');}int main(){int n;printf('请输入一个大于2的偶数：'); scanf('%d',&n);if(n%2!=0 || n<=2){printf('输入错误！');return 0;}verify_goldbach(n);return 0;}程序解释：1.首先定义了一个函数is_prime()，用于判断一个数是否为质数。
该函数使用了一个for循环，从2到n-1遍历每一个数，如果n 可以被其中任何一个数整除，则n不是质数，返回false。
判断质数的5个C语言程序
判断质数的5个C语言程序（含代码）——程序优化的重要性质数质数是指在一个大于1的自然数中，除了1和它本身之外，无法被其他自然数整除的数。
本文将会带领大家编写计算质数的程序。
质数计算程序(第1版)判断一个数mo是否为质数的方法就是看它能否被2、3、……、mo-1整除、如果它不能被其中任何一个整数整除，那么这个数就是质数。
例如我们要判断13是不是质数，就需要看它能否被下面这11个数整除。
2、3、4、5、6、7、8、9、10、11、12/*通过11次除法计算来判断其是否为质数*/因为13无法被其中任何一个数整除，所以可以确定它是质数。
但是对于12来说，并不需要使用2、3、4、5、6、7、8、9、10、11这十个数来判断它是不是质数。
也就是说，12能够被第一个数2整除，所以它就不是质数。
程序代码ver1：(绿色部分)/*30-5-2017*//*计算出1000以内的质数*/#include <stdio.h>int main(){inti,no;int counter=0;for(no=2;no<=1000;no++){for (i=2;i<no;i++){counter++;if (no%i==0) /*能被整除的不是质数,取余操作*/break; /*退出循环*/}if (no==i)/*直到最后未被整除*/printf("%d\n",no);}printf("乘除运算的次数:%d\n",counter);return 0;}运算结果：＊注意，这个程序的乘除运算次数为78022次。
质数计算程序(第2版)我们注意到，大于2的所有偶数都不是质数，所以在判断1000以内的质数时可以排除大于2的偶数，可以得到下边的程序：程序代码ver2：(绿色部分)/*30-5-2017*//*计算1000以内的质数（第2版）*/#include <stdio.h>int main(){inti,no;int counter=0;no=2;printf("%d\n",no++); /*2是偶数中唯一的质数，先打印出来*/for (;no<=1000;no+=2) /*只把奇数作为判断对象，排除大于2的偶数*/{for (i=2;i<no;i++){if (no%i==0) /*能被整除的不是质数*/break;}if (no==i) /*直到最后未被整除*/printf("%d\n",no);}printf("乘除运算的次数:%d\n",counter);return 0;}运算结果：＊可以看到乘除运算的次数减少了大约1000次。
质数(c语言练习)
for(i=2;i<=n;i++)
if(m%i==0) break;
if(i>n) printf("%d是素数!\n",m);
else printf("%d不是素数!\n",m);
}
#include <stdio.h>
void main()
{
int i,n,k=1;
printf("请输入一个正整数: ");
前言
质数表的质数又称素数。指整数在一个大于1的自然数中，除了1和此整数自身外，没法被其他自然数整除的数。换句话说，只有两个正因数（1和自己）的自然数即为素数。比1大但不是素数的数称为合数。1和0既非素数也非合数。
1、小学生版本：
判断x是否为质数，就从2一直算到x-1。
#include<stdio.h>
void main()
{
int i,n,k=0;
printf("请输入一个正整数: ");
scanf("%d",&n);
for(i=2;i<n;i++)
if(n%i==0)k++;
if(k==0)
printf("%d不是素数。",n);
else
printf("%d是素数。",n);
}
2、高中生版：
其实只要从2一直尝试到根号x，就可以了。因为x只要有因数必定有一个因数小于等于根号x。
void main()
{
int n,i;
scanf("%d",&n);
质数求和c语言
质数求和c语言以质数求和C语言质数是指只能被1和自身整除的自然数。
在数学中，质数具有很特殊的性质，也被广泛应用于计算机科学中的各个领域。
本文将介绍如何使用C语言计算质数的和。
在C语言中，我们可以通过循环和条件判断来判断一个数是否为质数。
首先，我们需要定义一个函数来判断一个数是否为质数。
以下是一个示例代码：```c#include <stdio.h>int isPrime(int num) {if (num <= 1) {return 0;}for (int i = 2; i * i <= num; i++) {if (num % i == 0) {return 0;}}return 1;}int main() {int n, sum = 0;printf("请输入一个正整数n：");scanf("%d", &n);for (int i = 2; i <= n; i++) {if (isPrime(i)) {sum += i;}}printf("质数的和为：%d\n", sum);return 0;}```在上述代码中，我们首先定义了一个函数isPrime，用于判断一个数是否为质数。
函数接受一个整数参数num，如果num小于等于1，直接返回0；否则，通过一个循环从2开始，判断num是否能被2到i-1之间的数整除，如果能整除则返回0，表示不是质数；如果循环结束后都没有找到可以整除的数，则返回1，表示是质数。
在主函数main中，我们首先定义了两个变量n和sum，n用于接收用户输入的正整数，sum用于保存质数的和。
然后，通过循环从2到n之间的数，依次判断每个数是否为质数，如果是则将其加到sum中。
最后，输出质数的和。
通过运行上述代码，我们可以得到输入正整数n后，计算得到的质数和。
例如，当我们输入10时，计算得到的质数和为17。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
判断质数的5个C语言程序（含代码）
——程序优化的重要性
质数
质数是指在一个大于1的自然数中，除了1和它本身之外，无法被其他自然数整除的数。
本文将会带领大家编写计算质数的程序。
质数计算程序(第1版)
判断一个数mo是否为质数的方法就是看它能否被2、3、……、mo-1整除、如果它不能被其中任何一个整数整除，那么这个数就是质数。
例如我们要判断13是不是质数，就需要看它能否被下面这11个数整除。
2、3、4、5、6、7、8、9、10、11、12/*通过11次除法计算来判断其是否为质数*/
因为13无法被其中任何一个数整除，所以可以确定它是质数。
但是对于12来说，并不需要使用2、3、4、5、6、7、8、9、10、11这十个数来判断它是
不是质数。
也就是说，12能够被第一个数2整除，所以它就不是质数。
程序代码ver1：(绿色部分)
/*30-5-2017*/
/*计算出1000以内的质数*/
#include <stdio.h>
int main()
{
inti,no;
int counter=0;
for(no=2;no<=1000;no++)
{
for (i=2;i<no;i++)
{
counter++;
if (no%i==0) /*能被整除的不是质数,取余操作*/
break; /*退出循环*/
}
if (no==i)/*直到最后未被整除*/
printf("%d\n",no);
}
printf("乘除运算的次数:%d\n",counter);
return 0;
}
运算结果：
＊注意，这个程序的乘除运算次数为78022次。
质数计算程序(第2版)
我们注意到，大于2的所有偶数都不是质数，所以在判断1000以内的质数时可以排除大于2的偶数，可以得到下边的程序：
程序代码ver2：(绿色部分)
/*30-5-2017*/
/*计算1000以内的质数（第2版）*/
#include <stdio.h>
int main()
{
inti,no;
int counter=0;
no=2;
printf("%d\n",no++); /*2是偶数中唯一的质数，先打印出来*/
for (;no<=1000;no+=2) /*只把奇数作为判断对象，排除大于2的偶数*/
{
for (i=2;i<no;i++)
{
if (no%i==0) /*能被整除的不是质数*/
break;
}
if (no==i) /*直到最后未被整除*/
printf("%d\n",no);
}
printf("乘除运算的次数:%d\n",counter);
return 0;
}
运算结果：
＊可以看到乘除运算的次数减少了大约1000次。
质数计算程序(第3版)
大于等于3的质数都无法被大于2的那些偶数整除（4、6、8、……）,t通俗的讲，例如要判断13是否为质数，不需要判断他是否被2、3、4、5、6、7、8、9、10、11、12这11个数整除，因为奇数肯定无法被偶数整除。
所以有以下程序：
程序代码ver3：(绿色部分)
/*30-5-2017*/
/*计算1000以内的质数（第三版）*/
#include <stdio.h>
{
inti,no;
intcouner=0;
no=2;
printf("%d\n",no++);
for (;no<=1000;no+=2) /*明确1000以内大于2的所有偶数不肯是质数*/
{
for (i=3;i<no;i+=2) /*奇数不能被偶数整除，排除3到no-1之间的偶数*/ {
couner++;
if (no%i==0)
break;
}
if (no==i)
printf("%d\n",no);
}
printf("the value of counter is:%d\n",couner);
return 0;
}
运算结果：
＊我们看到乘除的次数只有38678次。
质数计算程序(第4版)
在第三步的基础上，我们发现以下规律：
不能被3整除的整数也无法被大于3的那些3的倍数（6、9、……）整除不能被5整除的整数也无法被大于5的那些5的倍数（10、15、……）整除程序代码ver4：(绿色部分)
/*30-5-2017*/
/*计算1000以内的质数（第四版）*/
#include <stdio.h>
int main()
{
inti,no;
int prime[500];
intpt=0;
int counter=0;
prime[pt++]=2;
prime[pt++]=3;
for (no=5;no<=1000;no+=2)
{
for (i=1;i<pt;i++)
{
counter++;
if (no%prime[i]==0)
break;
}
if (pt==i)
prime[pt++]=no;
}
for (i=0;i<pt;i++)
printf("%d\n",prime[i]);
printf("乘除运算的次数为:%d\n",counter);
return 0;
}
运算结果：
＊乘除运算次数减少到了14622次！这就是所谓的程序优化，很强大！还没完呢，接着看！
质数计算程序(第5版)
~~~~~描述起来太复杂~~~直接上代码~~~~
程序代码ver5：(绿色部分)
/*30-5-2017*/
/*计算1000以内的质数（第五版）*/
#include <stdio.h>
int main()
{
intI,no;
int prime[500];
intptr=0;
int counter=0;
prime[ptr++]=2;
prime[ptr++]=3;
for (no=5;no<=1000;no+=2)
{
int flag=0;
for (i=1;counter++,prime[i]*prime[i]<=no;i++)
{
counter++;
if (no%prime[i]==0)
{
flag=1;
break;
}
}
if (!flag)
prime[ptr++]=no;
}
for (i=0;i<ptr;i++)
printf(“%d\n”,prime[i]);
printf(“乘除运算的次数:%d\n”,counter);
return 0;
}
运行结果：
＊由最初乘除运算78022次，到最后不断优化，减少到3774次，减少了10倍不止。
从这里也看到程序优化的重要性，特别是对大型程序而言更是如此！。