用C语言编写自定义函数prime(int x)，判断x是否为素数？
int  prime(int x)
{
int i，k
k=(int)sqrt( (double)x )
for(i=2i&lt=ki  )
if(x%i==0)
break
// 如果完成所有循环，那么x为素数
if(i&gtk)
retrun 1
else
return 0
}
C语言，编写函数判断一个整数是否为素数，在主函数中调用该函数并输出100以内的全部素数？
参考代码：
#include &ltstdio.h&gt
int is_prime_number(int n)
{
int i
int result = 1
if(n==1)
return 0
for(i=2i&ltni  )
{
if(n%i==0)
{
result = 0
break
}
}
return result
}
int main()
{
int n
printf("100以内的素数包括：")
for(n=1n&lt=100n  )
{
if(is_prime_number(n))
{
printf("%d "，n)
}
}
printf("")
return 0
}
编写程序，其中自定义函数，用来判断一个整数是否为素数，主函数输入一个数，输出是否为素数？
自己动手写吧，这是最基本的能力啦.....(课本一般会有的)
C  编程，编写函数判断变量是否为素数？
多的我就不说了，函数如下(你只需把下面的代码贴在intmain()之前就行了，然后在开头加一个头文件：#include
boolisPrime(intx){
if(x==1)return0
for(inti=2i
if(x%i==0)return0
return1}
函数就是上面的，使用方法：比如你想判断n(这里n为正整数)是否为素数，只需运行isPrime(n)，如果n是素数，则刚才的函数返回1，否则返回0.
不懂在发站内信问我
编程用自定义函数求100到200之间的素数？
#include "stdio.h" int isPrime(int n)//判断n是否是素数，是返回1，不是返回0 { int i for(i=2i&lt=n/2i  ) if(n%i==0) return 0 return 1 } int main() { int i printf("100到200之间的素数: ") for(i=100i&lt=200i  ) if(isPrime(i)==1) printf("%d"，i) printf(" ") }
python编写一个函数.判断一个数是不是素数，然后调用该函数输出100以内的素数？
def is_prime(n): list_num = [] for i in range(2， n): for num in range(2， int(sqrt(n)) 1): if i % num == 0 and i != num: break elif i % num != 0 and num == (int(sqrt(n))): list_num.append(i) return list_num

输入两个正整数m和n(m<n)，求m到n之间(包括m和n)所有素数的和，要求定义并调用函数isprime(x)来判断x是否为素数(素数是除1以外只能被自身整除的自然数)。

哈哈，致敬正在学习C语言的你！这个其实就是如何判断素数的问题，其实有很多方法，但是每次写都不太一样！

#include<stdio.h>
int isprime(int n)
{
    int i=2;
    for(i;i<n;i++)
    {
        if(n%i==0)
        break;            
    }
    if(i==n)
    return 1;
    else
    return 0;
}

int main()
{
    int m,n;
    int sum=0;
    scanf("%d %d",&m,&n);
    for(int i=m;i<=n;i++)
    {
        if(isprime(i))
           sum+=i;   
    }
    printf("%d",sum);
    return 0;
}


 

定义：约数只有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++代码如下：
bool isPrime_2( int num )
{
     int tmp =sqrt( num);
     for(int i= 2;i <=tmp; i++)
        if(num %i== 0)
          return 0 ;
     return 1 ;
}
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的相邻两侧。这里有个题外话，关于孪生素数，有兴趣的道友可以再另行了解一下，由于与我们主题无关，暂且跳过。这里要注意的一点是，在6的倍数相邻两侧并不是一定就是质数。
此时判断质数可以6个为单元快进，即将方法（2）循环中i++步长加大为6，加快判断速度，原因是，假如要判定的数为n，则n必定是6x-1或6x+1的形式，对于循环中6i-1，6i，6i+1,6i+2，6i+3，6i+4，其中如果n能被6i，6i+2，6i+4整除，则n至少得是一个偶数，但是6x-1或6x+1的形式明显是一个奇数，故不成立；另外，如果n能被6i+3整除，则n至少能被3整除，但是6x能被3整除，故6x-1或6x+1（即n）不可能被3整除，故不成立。综上，循环中只需要考虑6i-1和6i+1的情况，即循环的步长可以定为6，每次判断循环变量k和k+2的情况即可，理论上讲整体速度应该会是方法（2）的3倍。代码如下：
bool isPrime_3( int num )
{
                 //两个较小数另外处理
                 if(num ==2|| num==3 )
                                 return 1 ;
                 //不在6的倍数两侧的一定不是质数
                 if(num %6!= 1&&num %6!= 5)
                                 return 0 ;
                 int tmp =sqrt( num);
                 //在6的倍数两侧的也可能不是质数
                 for(int i= 5;i <=tmp; i+=6 )
                                 if(num %i== 0||num %(i+ 2)==0 )
                                                 return 0 ;
                 //排除所有，剩余的是质数
                 return 1 ;
}
算法性能测试：
编写测试代码，使用较多数据测试比较几种方法的判断效率，数据量40w，代码如下：
#include <iostream>
#include <string>
#include <ctime>
#include <vector>
using namespace std;
bool isPrime_1( int num );
bool isPrime_2( int num );
bool isPrime_3( int num );
int main()
{
                 int test_num =400000;
                 int tstart ,tstop; //分别记录起始和结束时间
                 //测试第一个判断质数函数
                 tstart=clock ();
                 for(int i= 1;i <=test_num; i++)
                                 isPrime_1(i );
                 tstop=clock ();
                 cout<<"方法(1)时间(ms):" <<tstop- tstart<<endl ;//ms为单位
                 //测试第二个判断质数函数
                 tstart=clock ();
                 for(int i= 1;i <=test_num; i++)
                                 isPrime_2(i );
                 tstop=clock ();
                 cout<<"方法(2)时间(ms):" <<tstop- tstart<<endl ;
                 //测试第三个判断质数函数
                 tstart=clock ();
                 for(int i= 1;i <=test_num; i++)
                                 isPrime_3(i );
                 tstop=clock ();
                 cout<<"方法(3)时间(ms):" <<tstop- tstart<<endl ;
                 cout<<endl ;
                 system("pause" );
                 return 0 ;
}

运行结果如下；


可以看出，判断到40w，效率上方法（1）明显要差得多，方法（2）和方法（3）在这种测试数量下时间相差2倍多

单独对比方法（2）和（3），数据量加到1000w，结果如下：

可以看出，方法（2）和方法（3）在这种测试数量下时间相差依然是2倍多，不过已经是很不错的提升。
对了，附上运行环境，CPU-i5-3210，内存4G，win7，vs2012。

好了，判断质数的方法暂时就到这里，不足之处欢迎各道友指出。

判断一个数x是否为素数
思路：

若一个数是素数，则它的因数只有“1”和它本身。

采用循环，依次从2开始到这个数x-1取模，若期间有(x%i==0)，则这个数必然不是素数。



代码：
import java.util.*;
public class Pra {
	static Scanner scan = new Scanner(System.in);
	public static void main(String[] args) {
		SuShu s = new SuShu();
		System.out.println("判断一个数是否为素数**");
		System.out.println("请输入一个数：");
		int x = scan.nextInt();
		s.Function(x);
	}
}
class SuShu{
	boolean flag =true;
	void Function(int x) {
		for(int i = 2;i < x; i++) {
			if(x%i==0) {
				flag = false;
				break;
			}
		}
		if(flag==true)
			System.out.println(x+"是素数");
		else
			System.out.println(x+"不是素数");
	}
}

*~~此文纯属记录作者学习日记，若有误导，纯属意外。~ *