C语言求质数
c语言判断范围内素数
c语言判断范围内素数以下是一个简单的 C 语言程序，用于判断一个范围内的素数（质数）：#include <stdio.h>#include <stdbool.h>// 判断是否为素数的函数bool isPrime(int num) {if (num <= 1) {return false;}for (int i = 2; i * i <= num; i++) {if (num % i == 0) {return false;}}return true;}// 输出范围内的素数void printPrimesInRange(int start, int end) {printf("Prime numbers in the range [%d, %d]:\n", start, end);for (int i = start; i <= end; i++) {if (isPrime(i)) {printf("%d ", i);}}printf("\n");}int main() {int start, end;// 输入范围printf("Enter the range (start end): ");scanf("%d %d", &start, &end);// 判断并输出范围内的素数printPrimesInRange(start, end);return 0;}这个程序中：isPrime 函数用于判断一个数是否为素数。
printPrimesInRange 函数用于输出指定范围内的所有素数。
在 main 函数中，用户被要求输入范围的起始值和结束值，然后程序调用 printPrimesInRange 函数来输出范围内的素数。
请注意，这只是一个简单的示例程序，可能并不是最优化或最高效的实现方式。
C语言素数的几种判断方法精编版
C语言素数的几种判断方法精编版
我们要判断素数，首先要知道素数的定义。
素数：质数又称素数。
一个大于1的自然数，除了1和它
自身外，不能被其他自然数整除的数叫做质数;否则称为
合数。
知道了素数的定义，那么我们应该想一下，如何去判断一个数是否为素数？
一种思路是，我们在每次得到一个数后，都去计算，去尝
试因式分解它，看它除了1和自身之外还有没有其他因子
另一种是，我们去查阅素数表，看这个数在不在素数表上。
那我们就要先得到素数表。
以下除了第一种方法，第2~4种方法都是用第二种思路做的当要判断的目标数很少时，第一种高效。
但是当给定的目标数组很多，数也很大时。
后面的思路配上高效的查找算法，显然更高效
方法：暴力求解
1-1:稍微动动脑
思想：根据素数的定义思考。
素数是大于1的自然数，除了1和自身外，其他数都不是它的因子。
那我们就可以用一个循环，从2开始遍历到这个数减去1，如果这个数都不能被整除，那么这个数就是素
数。
也就是说：给定一个数 n , i 从 2 开始取值，直到 n - 1(取整数),如果 n % i != 0 , n 就是素数进一步思考，有必要遍历到 n - 1 吗？除了1以外，任何合数最小的因子就是2，那最大的因子就是 n/2 那我们就遍历到 n/2就足够了。
C语言求素数（质数）Eratosthenes经典算法
//使用Erato sthene s方法找出指定范围内的所有质数#include <stdlib.h>#defineSIZE 500 //该方法能够求出2*SIZE 之内的质数#defineTRUE 1#defineFALSE 0intmain(){char sieve[ SIZE ]; /* the sieve */char *sp; /* pointer to accessthe sieve */int number; /* numberwe’re computi ng *//*** Set the entiresieve to TRUE.*/for(sp = sieve; sp<&sieve[ SIZE ]; )*sp++ = TRUE;/*** Process each numberfrom 3 to as many as the sieve holds. (Note: the** loop is termina ted from inside.)*/for( number= 3; ; number+= 2 ){/*** Set the pointer to the properelement in the sieve, and stop** the loop if we’ve gone too far.*/sp = &sieve[ 0 ] + ( number-3 ) / 2;if(sp>= &sieve[ SIZE ] )break;/*** Now advance the pointer by multipl es of the numberand set** each subsequ ent entry FALSE.*/while(sp += number, sp<&sieve[ SIZE ] )*sp = FALSE;}/*** Go through the entiresieve now and print the numbers corresp onding** to the locatio ns that remainTRUE.*/printf( "2\t" );for( number= 3, sp = &sieve[ 0 ];sp<&sieve[ SIZE ];number+= 2, sp++ ){if( *sp )printf( "%d\t", number);}system("pause");returnEXIT_SU CCESS; }。
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.素数和c 语言简介2.求素数个数的方法3.c 语言求素数个数方法超时的原因4.解决c 语言求素数个数方法超时的方法5.总结正文：1.素数和c 语言简介素数是指只能被1 和自身整除的正整数，它是数学中的一个重要概念。
在计算机科学中，c 语言是一种广泛应用的编程语言，其功能强大，可以实现各种算法和数据结构。
2.求素数个数的方法求素数个数的方法有很多，其中较为常见的方法是埃拉托斯特尼筛法（Sieve of Eratosthenes）和试除法。
这里我们以埃拉托斯特尼筛法为例进行介绍。
该算法的基本思想是：首先创建一个包含2 到n 的所有整数的数组，然后将数组中的所有元素设置为真（代表质数），接着从2 开始遍历到n，如果当前数字为质数，则将它的所有倍数的元素标记为非质数。
最后，数组中标记为真的元素个数即为n 以内的素数个数。
3.c 语言求素数个数方法超时的原因在实际编程过程中，有时候使用c 语言实现埃拉托斯特尼筛法时会出现超时现象。
这主要是因为该算法在遍历数组时，需要频繁地进行数组元素的标记操作，这会导致时间复杂度较高，特别是在n 较大时，计算时间会显著增加。
4.解决c 语言求素数个数方法超时的方法为了解决c 语言求素数个数方法超时的问题，我们可以从以下几个方面进行优化：（1）使用更高效的算法。
例如线性筛法（Linear Sieve）和欧拉筛法（Euler Sieve），它们在时间复杂度上比埃拉托斯特尼筛法更优秀。
（2）减少计算范围。
在实际应用中，我们往往只需要求一定范围内的素数个数，因此可以适当减小计算范围，从而减少计算量。
（3）使用并行计算。
利用多核处理器的优势，将算法分解为多个子任务并行执行，可以显著提高计算速度。
5.总结总之，虽然c 语言求素数个数方法可能会出现超时现象，但通过选择更高效的算法、减少计算范围和使用并行计算等方法，我们可以有效地解决这一问题。
C语言程序设计100例之(11)：求质数
scanf("%d%d",&a,&b);
for (i=a;i<=b;i++)
{
if (isPrime(i))
{
cnt++;
printf("%5d",i);
if (cnt%10==0) printf("\n");
}
}
return 0;
}
习题
11
问题描述
我国古代有一种回文诗，倒念顺念都有意思，例如“人过大佛寺”，倒读起来便是“寺佛大过人”。还有经典的对联“客上天然居，居然天上客”等。在自然数中，如果一个数从左向右读或是从右向左读完全一致，这样的自然数称为回文数。
输入样例
2009
输出样例
3 3 2003
（1）编程思路。
对输入的正奇数n，先判断其和是否含有质数2，只有一种可能2+2+（n-4），若n-4是质数，则直接输出结果，结束。
如果n的和值中不包含质数2，则只能分解为3个奇数之和。不妨设n=i+j+(n-i-j)。用一个二重循环寻找答案。外循环i为3~n/3之间的所有奇数，内循环j为i~n/3之间的所有奇数，在内循环中调用函数isPrime判断，若i、j、n-i-j三个数均为质数，则找到答案，输出并结束。
（2）源程序。
#include <stdio.h>
#include <math.h>
int isPrime(int m)
{
int i;
if (m==1) return 0;
for (i=2;i<=sqrt(1.0*m);i++)
最大素数c语言
最大素数的求解1. 什么是素数？素数是指只能被1和自身整除的正整数。
在数学中，素数也被称为质数。
素数是数字领域中的基本概念，对于很多数论问题都起到了至关重要的作用。
2. 如何判断一个数是否为素数？判断一个数是否为素数有多种方法，下面介绍两种常用的判断素数的方法。
2.1 蛮力法蛮力法是一种最简单直接的判断素数的方法，其基本思想是对待判断的数从2开始，逐个除以所有小于它的自然数，如果能被除尽，则该数不是素数；如果不能被除尽，则该数是素数。
蛮力法的C语言代码如下:#include <stdio.h>int isPrime(int num) {if (num < 2) {return 0;}for (int i = 2; i * i <= num; i++) {if (num % i == 0) {return 0;}}return 1;}int main() {int n;printf("请输入一个正整数: ");scanf("%d", &n);if (isPrime(n)) {printf("%d是素数\n", n);} else {printf("%d不是素数\n", n);}return 0;}2.2 埃氏筛法埃氏筛法是一种更高效的判断素数的方法，其基本思想是从2开始，将每个素数的倍数标记为合数，直到遍历完所有小于等于待判断数的自然数，剩下的未被标记的数即为素数。
埃氏筛法的C语言代码如下:#include <stdio.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("小于等于%d的素数有: ", n);for (int i = 2; i <= n; i++) {if (isPrime[i]) {printf("%d ", i);}}printf("\n");}int main() {int n;printf("请输入一个正整数: ");scanf("%d", &n);sieveOfEratosthenes(n);return 0;}3. 求解最大素数有了判断素数的方法，我们可以通过遍历一定范围内的数，找到其中的最大素数。
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>
C语言求质数
【C语言】求解素数（质数）的N种境界★试除法：首先要介绍的，当然非"试除法"莫属。
"试除"，顾名思义，就是不断地尝试能否整除。
比如要判断自然数x 是否质数，就不断尝试小于x 且大于1的自然数，只要有一个能整除，则x 是合数；否则，x 是素数。
显然，试除法是最容易想到的思路。
不客气地说，也是最平庸的思路。
不过呢，这个最平庸的思路，也有好多种境界。
不信请看下文：◎境界1假设要判断x 是否为质数，就从2 一直尝试到x-1。
这种做法，其效率应该是最差的1.#include<stdio.h>2.#include<Windows.h>3.int main()4.{5. int i = 0,k = 0;6. int count = 0;7. for(i=100; i<=200; i++)8. {9. for(k=2; k<i; k++)10. {11. if(i%k == 0)12. break;13. }14. if(k == i)15. printf("%d是素数\n",i);16. count++;17. }18. printf("\n%4d",count);19. system("pause");20. return 0;}◎境界2所有素数都是偶数，因此可以加快步长1.#include<stdio.h>2.#include<Windows.h>3.int main()4.{5. int i = 0, k = 0;6. int count = 0;7. for(i=101; i<=200; i+=2)8. {9. for(k=2; k<i; k++)10. {11. if(i%k == 0)12. break;13. }14. if(k==i)15. printf("%d是素数\n",i);16. count++;17. }18. printf("\n%4d",count);19. system("pause");20. return 0;21.}◎境界3除了2以外，所有可能的质因数都是奇数。
c语言典型问题处理方法小结
c 语言典型问题处理方法小结一、 循环问题 （1）、数论问题 1、求素数for(i=2;i<=a;i++) if(a%i==0)break;if (a==i)printf("yes\n");elseprintf("no\n"); 素数概念：对于某个整数a>1，如果它仅有平凡约数1和a ，则我们称a 为素数(或质数)。
整数 1 被称为基数，它既不是质数也不是合数。
整数 0 和所有负整数既不是素数，也不是合数。
2、求最大公约数和最小公倍数 a 、if(a>b) {t=a; a=b; b=t; }for(i=a;i>=1;i--)if(a%i==0&&b%i==0) break;printf("largest common divisor:%d\n",i);printf("least common multiple:%d\n",(a*b)/is); b 、辗转相除法求解 a1=a; b1=b;while(a%b!=0) {t=a%b; a=b; b=t; }printf("largest common divisor:%d\nleast common multiple:%d",b,a1*b1/b); 3、求完数一个数如果恰好等于它的因子之和，这个数就称为“完数”。
例如：6的因子为1、2、3，而6＝1＋2＋3，因此6是“完数”。
第一个if 判断是否能被2，3，4……直到本身整除。
第二个if 判断是否只能被本身整除。
for(a=1;a<=1000;a++) { s=0;for(i=1;i<=a;i++) if (a%i==0) { s+=i; if(s>=a) break; } if(s==a)printf("%d\t",a); }4、分解质因数将一个整数写成几个质因数的连乘积，如： 输入36，则程序输出36=2*2*3*3 。
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的相邻两侧。
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语言编程题
判断质数c语言编程题质数，又称素数，是指在大于1的自然数中，除了1和它本身以外，不能被其他自然数整除的数。
质数在数学中有着重要的应用，如加密算法、概率论等。
本篇文章主要介绍如何使用C语言编程来判断一个数是否为质数。
1. 基本概念在C语言中，判断一个数是否为质数的方法是通过循环来实现的。
首先，需要明确一个概念：因子。
因子是指能够整除一个数的自然数。
例如，6的因子为1、2、3和6本身。
如果一个数只有两个因子，即1和它本身，那么这个数就是质数。
如果一个数有多于两个因子，那么这个数就是合数。
2. 判断质数的方法常见的判断质数的方法有两种：试除法和筛法。
试除法是指对于一个数n，从2到n-1逐一试除，如果都不能整除，则n为质数。
筛法是指用一张表来记录一个数是否为质数，然后依次排除这个数的倍数，最终剩下的数就是质数。
这两种方法各有优缺点，但在实际编程中，一般采用试除法。
3. 代码实现下面是一个简单的C语言程序，用于判断一个数是否为质数：```c#include <stdio.h>int main()int n, i, flag = 0;printf('Enter a positive integer: '); scanf('%d', &n);for (i = 2; i <= n / 2; ++i) {// condition for non-primeif (n % i == 0) {flag = 1;break;}}if (n == 1) {printf('1 is not a prime number.');}else {if (flag == 0)printf('%d is a prime number.', n);elseprintf('%d is not a prime number.', n); }return 0;}在这个程序中，我们首先从用户输入一个数n，然后从2到n/2逐一试除，判断n是否能被i整除。
c 求质因子
c 求质因子C语言是一门非常重要的编程语言，在计算机科学、算法和软件开发领域中都有着广泛的应用。
在C语言中，我们可以写出许多不同的程序，其中包括求质因数的程序。
在这篇文章中，我们将会详细介绍如何用C语言来写一个求质因数的程序。
第一步：定义变量在开始编写程序之前，我们首先需要定义一些变量。
这些变量包括要被分解的数、当前质数、当前指数和当前因子。
在这里，我们使用long类型来存储这些变量。
long number; /* 要被分解的数 */long factor; /* 当前质数 */long exponent; /* 当前指数 */long remainder; /* 当前因子 */第二步：输入要分解的数在定义好变量之后，我们需要输入一个要分解的数。
在这个程序中，我们使用scanf()函数来读取用户输入的数。
printf("请输入一个整数：");scanf("%ld", &number);第三步：找出质因数接下来，我们需要找到这个数的所有质因数。
我们可以使用一个while循环来完成这个任务。
在这个循环里，我们通过除以当前质数，不断地得到当前质数的指数，直到除不尽为止。
factor = 2; /* 起始质数为2 */while (number > 1) { /* 如果还存在因子 */exponent = 0; /* 当前指数清零 */while (number % factor == 0) { /* 当前质数仍然是因子 */exponent++; /* 指数加1 */number /= factor; /* 剩余数更新 */}if (exponent > 0) { /* 如果存在因子 */printf("%ld^%ld ", factor, exponent); /* 输出因子及指数 */}factor++; /* 质数增加一个 */}第四步：输出质因数最后，我们通过printf()函数来输出所有的质因数。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
试编写一个程序，找出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就是素数。
观点对，但却与上一点一样的笨拙。
当i>2时，有哪一个数可以被i-1除尽的？没有，为什么？如果i不是质数，那么i=a×b，此地a与b既不是i又不是1；正因为a>1，a至少为2，因此b最多也是i/2而已，去除i的数用不着是2~i-1，而用2~i/2就可以了。
不但如此，因为i=a×b，a与b不能大于sqrt(i),为什么呢？如果a>sqrt(i),b>sqrt(i),于是a×b>sqrt(i)*sqrt(i)=i，因此就都不能整除i了。
如果i不是质数，它的因子最大就是sqrt(i)；换言之，用2~sqrt(i)去检验就行了。
但是，用2~sqrt(i)去检验也是浪费。
就像前面一样，2除不尽，2的倍数也除不尽；同理，3除不尽，3的倍数也除不尽……最理想的方法就是用质数去除i。
但问题是这些素数从何而来？这比较简单，可以准备一个数组prime[]，用来存放找到的素数，一开始它里面有2、3、5。
检查的时候，就用prime[]中小于sqrt(i)的数去除i即可，如果都除不尽，i就是素数，把它放如prime[]中，因此prime[]中的素数会越来越多，直到满足个数为止！
不妨用这段说明来编写这个程序，但是程序设计的时候会有两个小问题：
1.如果只检查6n+1和6n+5？不难发现，它们的距离是4、2、4、2……所以，可以先定义一个变量gab=4，然后gab=6-gab;
2.比较是不能用sqrt(i)，因为它不精确。
举个例子，i=121，在数学上，sqrt(i)自然是11，但计算机里的结果可能是10.9999999，于是去除的数就是2、3、5、7，而不含11，因此121就变成质数了。
解决这个问题的方法很简单，不要用开方，用平方即可。
例如，如果p*p<=i，则就用p去除i。
而且它的效率比开方高。
【程序清单】：
#include <stdio.h>
int creat_prime(int prime[],int n,int total)
{
register int i;
register int j;
register int gab=2;
register int count;
for(i=7;i<=n;i+=gab)
{
count=1;
gab=6-gab;
for(j=0;prime[j]*prime[j]<=i;j++)
{
if(i%prime[j]==0)
{
count=0;
break;
}
}
if(count)
{
prime[total]=i;
total++;
}
}
return total;
}
int main(void)
{
int prime[30000]={2,3,5};
int total=3;//找到素数的个数
int i;
int n=200000;//要查找的范围(>=6)
total=creat_prime(prime,n,total);
for(i=0;i<total;i++)
{
printf("%d ",prime[i]);
if(i && !(i%10))
putchar('\n');
}
putchar('\n');
}
如果你有VC++或其他C编译器，可以去运行一下。
你会发现，会有很多时间去输出。
我给个小提示，
假设你编译生成的可执行文件是prime.exe，目录在D:\
那你在命令行下进如D:\然后输入命令 prime >1.txt
这样就可以把结果保存到1.txt。
你会发现在int越界的前提下，它几乎都是瞬间完成的！
当然这段程序还是有可以改进的地方，如果你有更好的建议，请联系我。
redraiment@
#include "stdio.h"
#include "conio.h"
main()
{ int m,n,i,num;
int p[100];
long s;
s=2;
m=1;
n=1;
num=1;
p[1]=2 ;
for (;num<100;num++);
{for (i=1,m=2;;)
{m=p[i] ;
if (m>s/2) break;
else if(m*n<s) n++ ;
else if (m*n==s) s++ ;
else if(m*n>s)i++ ;
}
printf ("p%d=%ld",num,s);
s++;
}
getch();
}
自己写的，感觉没有问题
运行结果总是：
p100=2
郁闷~~~
求错
问题补充：
哦~~被wintc的提醒弄狂了~~
是这样的
我用p[i]是想表示第i个质数
貌似这样有问题？？
请问还有救吗？
能不能实现类似的定义？？？
最佳答案
有救！有救！
你的思路挺好的，就是编程的时候思路不清晰，没有周全考虑。
这是改后的代码
#include "stdio.h"
#include "conio.h"
main()
{ int m,n,i,num;
int p[100];
long s;
s=2;
m=1;
n=1;
num=1;
p[1]=2 ;
for (;num<100;num++)/*这里的分号应该是你笔误吧O(∩_∩)O*/
{for (i=1,n=2;;) /*这里n=2而非m估计也是你笔误？*/
{m=p[i] ;
if (m>s/2) break;
else if(m*n<s) n++;
else if(m*n==s) {s++;i=1;n=2;}/*这里*/
else if(m*n>s) {i++;n=2;}/*和这里，仔细想一想，当尝试一个新的数字或尝试一个新的质数时，是不是要把计数变量初始化？*/
/*编程的时候不要想当然，要通盘考虑，每个变量是否都做了妥善的处理*/
}
p[num]=s;/*你要用质数表，怎么能不记录质数表呢^o^*/
printf ("p%d=%ld\n",num,s);
s++;
}
getch();
}
你的程序运用质数表这点很好，但是你的程序还没发挥到最高效率。
里边有一些无用的判断和赋值，而且没有利用mod运算，使程序既复杂又低效。
我觉得还是用标准的求质数算法比较好，到处都有，不再说了。