判断素数的c语言算法

⑴ c语言求素数的算法

根据素数的性质，代码设计如下：

设计一：判断n是否能被1~n-1整除，不能整除为素数

#include<stdio.h>

int main()

{

int i, n;

scanf("%d", &n);

for (i = 2; i < n ; i++)

{

if (n%i == 0)

break;

}

if (i < n) printf("This is not a prime.");

else printf("This is a prime.");

return 0;

}

设计二：判断n是否能被2~√n间的整数整除，不能整除为素数

#include<stdio.h>

#include<math.h>

int main()

{

int n,i;

double k;

scanf("%d", &n);

k = sqrt(n);

for (i = 2; i <= k;i++)

{

if (n%i == 0) break;

}

if (i <=k) printf("This is not a prime.");

else printf("This is a prime");

return 0;

}

(1)判断素数的c语言算法扩展阅读：

1.素数的定义是只能被1和他本身整除,1不是素数.因此要判断一个数是否为素数.就要判断它能不能被比他小的所有素数整除,这是一个算法.(写到算法时,我只能写出用它除以比他小的所有数,造成运算速度低下)

2.如果一个质数大于根号n，而n可以除尽它，那么n必然也可以除尽一个更小的质数。由此可以得到一个法2较快的素数判断算法

⑵ c语言判断素数共有几种方法

判断是不是素数，素数就是只能被1和本身整除的自然数。
void
main()
{
int
m,i,k;
printf("please
input
a
number:\n");
scanf("%d",&m);
k=sqrt(m);
for(i=2;i<k;i++)
if(m%i==0)
break;
if(i>=k)
printf("该数是素数");
else
printf("该数不是素数");
}

⑶ C语言中怎么判断素数

首先分析需求，素数是指 除了1和它本身以外，不能被任何数整除的数。例如：1，3，5，7，11，13.。。。。。。。

例如输入一个数m，判断m是否是素数。我们可以用 m向小于m大于1的所有整数求余。如果有一个值是等于0，那么，就能证明这个数是素数。
m %（2...（m-1）） == 0。

当然，更好的算法是 m 向 （小于或等于 m的中位数） （大于1） 的所以数求余。
m%(2...(m/2)) == 0

如果你只想求实际代码，当我没说过。因为我这只是提供一个思路。

⑷ 编写一个C语言程序判断一个数是否是素数

目的：判断一个数是否为素数

#include<stdio.h>

intmain(void)

{

int m;

inti;

scanf("%d",&m);

for(i=2;i< m;i++) //2到(m-1)的数去除m

{

if(m%i==0)//判断能否整除

break;

}

if(i== m)

printf("YES! ");

else

printf("No! ");

}

for循环的功能：

①若能整除，通过break跳出函数;

②若一直到m-1都不能整除，此时i再自增1到m，不满足i< m跳出for循环，这时i= m。

(4)判断素数的c语言算法扩展阅读：

素数定理：

1、在一个大于1的数a和它的2倍之间（即区间（a,2a]中）必存在至少一个素数。

2、存在任意长度的素数等差数列。

3、一个偶数可以写成两个合数之和，其中每一个合数都最多只有9个质因数。（挪威数学家布朗，1920年）。

4、一个偶数必定可以写成一个质数加上一个合成数，其中合数的因子个数有上界。（瑞尼，1948年）。

5、一个偶数必定可以写成一个质数加上一个最多由5个因子所组成的合成数。后来，有人简称这结果为（1+5）（中国潘承洞，1968年）。

6、一个充分大偶数必定可以写成一个素数加上一个最多由2个质因子所组成的合成数。简称为（1+2）。

⑸ C语言判断素数

#include "stdafx.h"
#include <stdio.h>
#include <iostream>
using namespace std;
int prime(int x){
for(int i=2;i<x;i++){
if(x%i==0)
return 0;
}
return 1;
}
int main(){
int a=0; // 素数的个数
int num[9]; // 输入的整数
int numl[9]={0};
printf("输入10个整数：\n");
cfu:
//有个小BUG需要输入11个数，最后一个不算入计算之内。
for(int i = 0;i < 10;i++){
scanf("%d\n",&num[i]);
}
for (int i = 0;i < 10;i++)
{
if (num[i] >= 50 && num[i] <= 2000)
{
//判断是不是素数；
if(prime(num[i])==1){
printf("%d 不是素数\n",num[i]);
}
else{
printf("%d 是素数\n",num[i]);
numl[a++] = num[i];
}
}else{
printf("请输入50到2000之间的数\n");
goto cfu;
}
}
//排序写在这里就可以了。
int lenth = a;
cout << "长度为: "<< lenth << endl;
for (int i = 0;i < lenth-1;i++)
{
for (int j = 0;j < lenth-1-i;j++)
{
if (numl[j] < numl[j+1] )
{
int temps = numl[j];
numl[j] = numl[j+1];
numl[j+1] = temps;
}
}
}
for (int i=0;i<lenth;i++)
{
printf("%d ",numl[i]);
}
while(1);
return 0;
}
//好像看错题了，我的是输入10个数判断是否是素数，，，，，
//这个重新写了一个，就符合题的意思了,你想输出其他的素数就自己加条件,当成拓展就可以了.
#include "stdafx.h"
#include <iostream>
using namespace std;
int prime(int x){
for(int i= 2;i< x ; i++){
if(x%i == 0)
return 0;
}
return 1;
}
int _tmain(int argc, _TCHAR* argv[])
{
int m,k=0;
int arr[2000]={0};
printf("输入50到2000之间的整数: ");
cfu:
scanf("%d",&m);
if (m >= 50 && m <= 2000)
{
//判断在m以内有素数
for (int i =2;i < m; i++)
{
if (prime(i)==1){
printf("%d 是素数\n",i);
arr[k++]= i;
if (k == 10)
{
break;
}
}else{
printf("%d 不是素数\n",i);

}
}

}else{
printf("输入50到2000之间的整数");
goto cfu;
}
cout << "K的值： "<< k << endl;
for (int i = 0;i < k-1;i++)
{
for (int j = 0;j < k-1-i;j++)
{
if (arr[j] < arr[j+1] )
{
int temps = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temps;
}
}
}
printf("10个数排序：");
for (int i = 0;i< k; i++)
{
printf("%d ",arr[i]);
}
while(1);
return 0;
}

⑹ 如何编写一个C语言程序判断一个数是否是素数

1. 思路1：

   判断一个整数m是否是素数，只需把m被 2 ~ m-1 之间的每一个整数去除，如果都不能被整除，那么m就是一个素数。代码如下：
   #include <stdio.h>
   int main(){
   int a=0; // 素数的个数
   int num=0; // 输入的整数
   printf("输入一个整数：");
   scanf("%d",&num);
   for(int i=2;i<num;i++){
   if(num%i==0){
   a++; // 素数个数加1
   }
   }
   if(a==0){
   printf("%d是素数。 ", num);
   }else{
   printf("%d不是素数。 ", num);
   }
   return 0;
   }

2. 思路2：

   另外判断方法还可以简化。m不必被 2 ~ m-1 之间的每一个整数去除，只需被 2 ~ 之间的每一个整数去除就可以了。如果m不能被 2 ~ 间任一整数整除，m必定是素数。例如判别17是是否为素数，只需使17被2~4之间的每一个整数去除，由于都不能整除，可以判定17是素数。代码如下：

   #include <stdio.h>
   #include <math.h>
   void main(){
   int m; // 输入的整数
   int i; // 循环次数
   int k; // m 的平方根
   printf("输入一个整数：");
   scanf("%d",&m);
   // 求平方根，注意sqrt()的参数为 double 类型，这里要强制转换m的类型
   k=(int)sqrt( (double)m );
   for(i=2;i<=k;i++)
   if(m%i==0)
   break;
   // 如果完成所有循环，那么m为素数
   // 注意最后一次循环，会执行i++，此时 i=k+1，所以有i>k
   if(i>k)
   printf("%d是素数。 ",m);
   else
   printf("%d不是素数。 ",m);
   return 0;
   }
   

⑺ 求"求素数的C语言程序"

#include <stdio.h>

int main()

{

int a=0;

int num=0;

int i;

printf("输入一个整数：");

scanf("%d",&num);

for(i=2;i<num;i++){

if(num%i==0){

a++;

}

}

if(a==0){

printf("%d是素数。 ", num);

}else{

printf("%d不是素数。 ", num);

}

return 0;

}

(7)判断素数的c语言算法扩展阅读：

质数又称素数。一个大于1的自然数，除了1和它自身外，不能被其他自然数整除的数叫做质数；否则称为合数。

基本算法：若 k%m==0 则说明 k 不是素数。

判断整数n是否为素数——采用枚举法求解。

采用枚举算法解题的基本思路：

（1）确定枚举对象、枚举范围和判定条件；

（2）枚举可能的解，验证是否是问题的解。

枚举算法的一般结构：while循环。

参考资料来源：网络-枚举法

⑻ c语言如何判断素数

素数又称质数，所谓素数是指除了 1 和它本身以外，不能被任何整数整除的数，例如17就是素数，因为它不能被 2~16 的任一整数整除。判断一个整数m是否是素数，只需把 m 被 2 ~ m-1 之间的每一个整数去除，如果都不能被整除，那么 m 就是一个素数。

首先要知道素数是不等于1，它的因子只有1和它本身。判断一个数是否为素数，可以用大于1小于给定数的所有数去除给定数，如果有任何一个能够除尽，就表示是合数，反之是素数。

(8)判断素数的c语言算法扩展阅读：

首先，本文英文字母都表示整数，上半部B 》3N 》W，下半部B 》W 》3N。大于3的素数只有6N-1和6N+1两种形式，我们只需判定这两种数是素数还是合数即可。

命题 1 对于B=36N+1 形数而言。

若不定方程（3N）^2+N-（B-1）/36=W^2 有整数解，

则 6（3N-W）+1 是小因子数；6（3N+W）+1 是大因子数。

若不定方程 （3N）^2-N-（B-1）/36=W^2 有整数解，

则 6（3N-W）-1 是小因子数；6（3N+W）-1 是大因子数。

两式都无解，是素数。

⑼ 求C语言中 判断素数的 代码!!!!!

基本思想：把m作为被除数，将2—INT（ ）作为除数，如果都除不尽，m就是素数，否则就不是。

可用以下程序段实现：

void main()

{ int m,i,k;

printf("please input a number: ");

scanf("%d",&m);

k=sqrt(m);

for(i=2;i<k;i++)

if(m%i==0) break;

if(i>=k)

printf("该数是素数");

else

printf("该数不是素数");

}

将其写成一函数,若为素数返回1，不是则返回0

int prime( m%)

{int i,k;

k=sqrt(m);

for(i=2;i<k;i++)

if(m%i==0) return 0;

return 1;

}

(9)判断素数的c语言算法扩展阅读：

筛法求素数

一、基本思想

用筛法求素数的基本思想是：

把从1开始的、某一范围内的正整数从小到大顺序排列， 1不是素数，首先把它筛掉。剩下的数中选择最小的数是素数，然后去掉它的倍数。依次类推，直到筛子为空时结束。

如有：

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

1不是素数，去掉。剩下的数中2最小，是素数，去掉2的倍数，余下的数是：

3 5 7 9 11 13 15 17 19 21 23 25 27 29

剩下的数中3最小，是素数，去掉3的倍数，如此下去直到所有的数都被筛完，求出的素数为：

2 3 5 7 11 13 17 19 23 29

二、C++实现

1、算法一：令A为素数，则A*N（N>1;N为自然数）都不是素数。

#definerange2000

bool

IsPrime[range+1];

/*set函数确定i是否为素数，结果储存在IsPrime[i]中，此函数在DEV

C++中测试通过*/

voidset(boolIsPrime[])

{

inti,j;

for(i=0;i<=range;++i)

IsPrime[i]=true;

IsPrime[0]=IsPrime[1]=false;

for(i=2;i<=range;++i)

{

if(

IsPrime[i])

{

for(j=2*i;j<=range;j+=i)

2、

说明：解决这个问题的诀窍是如何安排删除的次序，使得每一个非质数都只被删除一次。 中学时学过一个因式分解定理，他说任何一个非质（合）数都可以分解成质数的连乘积。

例如，16=2^4，18=2 * 3^2，691488=2^5 * 3^2 * 7^4等。如果把因式分解中最小质数写在最左边，有16=2^4，18=2*9,691488=2^5 * 21609,；

换句话说，把合数N写成N=p^k * q，此时q当然是大于p的，因为p是因式分解中最小的质数。由于因式分解的唯一性，任何一个合数N，写成N=p^k * q;的方式也是唯一的。

由于q>=p的关系，因此在删除非质数时，如果已知p是质数，可以先删除p^2,p^3,p^4,... ，再删除pq,p^2*q,p^3*q,...,（q是比p大而没有被删除的数），一直到pq>N为止。

因为每个非质数都只被删除一次，可想而知，这个程序的速度一定相当快。依据Gries与Misra的文章，线性的时间，也就是与N成正比的时间就足够了（此时要找出2N的质数）。

代码如下：

#include<iostream>

#include<cmath>

usingnamespacestd;

intmain()

{

intN;cin>>N;

int*Location=newint[N+1];

for(inti=0;i!=N+1;++i)

Location[i]=i;

Location[1]=0;//筛除部分

intp,q,end;

end=sqrt((double)N)+1;

for(p=2;p!=end;++p)

{

if(Location[p])

{

for(q=p;p*q<=N;++q)

{

for(intk=p*q;k<=N;k*=p)

Location[k]=0;

}

}

}

intm=0;

for(inti=1;i!=N+1;++i)

{

if(Location[i]!=0)

{

cout<<Location[i]<<"";

++m;

}

if(m%10==0)cout<<endl;

}

cout<<endl<<m<<endl;

return0;

}

该代码在Visual Studio 2010 环境下测试通过。

以上两种算法在小数据下速度几乎相同。