挺好的，我也来写一个，咱们相互学习下。 

using System;

using System.Linq;



namespace T392516451

{

    class Program

    {

        static void Main(string[] args)

        {

            int n = 100;

            bool[] cond = Enumerable.Range(2, n - 1).Select(x => true).ToArray();

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

            {

                if (cond[i - 2])

                {

                    Console.WriteLine("prime = {0}", i);

                    int j = 1;

                    while (++j * i <= n)

                        cond[j * i - 2] = false;

                }

            }

        }

    }

}

你们俩都可以改进一点，所有2结尾的数字都能被2整除，因此第一个循环直接i+2，不再循环偶数即可。

引用 3 楼 胖叔叔写代码的回复:

你们俩都可以改进一点，所有2结尾的数字都能被2整除，因此第一个循环直接i+2，不再循环偶数即可。

谢谢啦。多谢帮助。我再思考一下。

引用 3 楼 胖叔叔写代码 的回复:

你们俩都可以改进一点，所有2结尾的数字都能被2整除，因此第一个循环直接i+2，不再循环偶数即可。

我的代码也有你说的问题吗。求教。谢谢。

引用 5 楼 caozhy 的回复:

Quote: 引用 3 楼 胖叔叔写代码 的回复:

你们俩都可以改进一点，所有2结尾的数字都能被2整除，因此第一个循环直接i+2，不再循环偶数即可。

我的代码也有你说的问题吗。求教。谢谢。

他说的是偶数都不可能是质数（2除外）所以没必要判断除2以外的偶数，只判断奇数。for (int i = 2; i <= n; i++)改为for (int i = 2,int j=1; i <= n; i=2*(++j)-1)循环次数就降低了

引用 6 楼 liusa1997 的回复:

Quote: 引用 5 楼 caozhy 的回复:

Quote: 引用 3 楼 胖叔叔写代码 的回复:

你们俩都可以改进一点，所有2结尾的数字都能被2整除，因此第一个循环直接i+2，不再循环偶数即可。

我的代码也有你说的问题吗。求教。谢谢。

他说的是偶数都不可能是质数（2除外）所以没必要判断除2以外的偶数，只判断奇数。for (int i = 2; i <= n; i++)改为for (int i = 2,int j=1; i <= n; i=2*(++j)-1)循环次数就降低了

懂了

if (cond[i - 2]) 这个判断相对来说，基本上可以说不损耗什么性能。

可以把最后那个乘法也去掉

    var 筛 = new bool[101];

    Console.WriteLine("prim={0}", 1);

    for (var prim = 2; prim < 筛.Length; prim++)

    {

        if (!筛[prim])  //没有被剔除掉，所以是质数

        {

            Console.WriteLine("prim={0}", prim);

            for (var i = prim + prim; i < 筛.Length; i += prim)

                筛[i] = true;    //被剔除掉了

        }

    }

但是我估计如果改为

    var 筛 = new bool[101];

    Console.WriteLine("prim={0}", 1);

    for (var prim = 2; prim < 筛.Length; prim++)

    {

        if (!筛[prim])  //没有被剔除掉，所以是质数

        {

            Console.WriteLine("prim={0}", prim);

            for (var i = prim + prim; i < 筛.Length; i += prim)

                筛[i] = true;    //被剔除掉了

        }

        if (prim > 2)   //目地是跳过偶数判断

            prim++;

    }

估计意思不大。感兴趣的人可以测试一下，用数据来说明增加最后一个 if 判断到底有多大意义。

为了“跳过偶数”而增加这样一个 if 判断和 ++ 计算我觉得可能意义不大。如果是增加为  i=2*(++j)-1 四则计算，我觉得可能意思就更不大了，甚至是降低性能的了！

引用 3 楼 胖叔叔写代码 的回复:

你们俩都可以改进一点，所有2结尾的数字都能被2整除，因此第一个循环直接i+2，不再循环偶数即可。

按照你的思路我修改了，请指教

using System;

using System.Linq.Expressions;

namespace T392516451

{

    class Program

    {

        static void Main(string[] args)

        {

            Expression<Func<int, bool>> cond = x => true;

            int N = 100;

            for (int i = 2; i < N; i++)

            {

                if (cond.Compile()(i))

                {

                    Console.WriteLine("prime {0}", i);

                    cond = (Expression<Func<int, bool>>)Expression.Lambda(

                        Expression.And(

                            cond.Body, Expression.NotEqual(

                                Expression.Modulo(

                                    cond.Parameters[0], Expression.Constant(i)), Expression.Constant(0))),

                        cond.Parameters);

                }

            }

        }

    }

}

如果直接打印质数2，那么倒是可以写

            Console.WriteLine("prim={0}", prim);//2为最小质数，所以先打印出来          

            for (prim=3; prim <=100; prim+=2)//质数

引用 11 楼 caozhy 的回复:

Quote: 引用 3 楼 胖叔叔写代码 的回复:

你们俩都可以改进一点，所有2结尾的数字都能被2整除，因此第一个循环直接i+2，不再循环偶数即可。

按照你的思路我修改了，请指教

using System;

using System.Linq.Expressions;

namespace T392516451

{

    class Program

    {

        static void Main(string[] args)

        {

            Expression<Func<int, bool>> cond = x => true;

            int N = 100;

            for (int i = 2; i < N; i++)

            {

                if (cond.Compile()(i))

                {

                    Console.WriteLine("prime {0}", i);

                    cond = (Expression<Func<int, bool>>)Expression.Lambda(

                        Expression.And(

                            cond.Body, Expression.NotEqual(

                                Expression.Modulo(

                                    cond.Parameters[0], Expression.Constant(i)), Expression.Constant(0))),

                        cond.Parameters);

                }

            }

        }

    }

}

引用 7 楼 caozhy 的回复:

Quote: 引用 6 楼 liusa1997 的回复:

Quote: 引用 5 楼 caozhy 的回复:

Quote: 引用 3 楼 胖叔叔写代码 的回复:

你们俩都可以改进一点，所有2结尾的数字都能被2整除，因此第一个循环直接i+2，不再循环偶数即可。

我的代码也有你说的问题吗。求教。谢谢。

他说的是偶数都不可能是质数（2除外）所以没必要判断除2以外的偶数，只判断奇数。for (int i = 2; i <= n; i++)改为for (int i = 2,int j=1; i <= n; i=2*(++j)-1)循环次数就降低了

懂了

就像sp最后说的，直接在循环上动手而不是在循环中加判断：

for (prim=3; prim <=100; prim+=2)//质数

这样去做会快很多。
你都明知道这是偶数可以排除了根本不需要再去做任何判断，直接在循环中跳过即可。
那么同理我们在循环中还可以跳过5这个特殊的奇数，但是for循环的灵活性没有那么高，用while可以实现，但是实现这个可读性很差，节约的资源并不多，因此循环中跳过偶数是我个人观点最合适的做法了。

public static bool IsPrime(int i)
        {
            return !Regex.IsMatch(new string('*', i), "^.?$|^(..+?)\\1+$");
        }

引用 14 楼 desperaso 的回复:

public static bool IsPrime(int i)
        {
            return !Regex.IsMatch(new string('*', i), "^.?$|^(..+?)\\1+$");
        }

好吧，这个屌 

                for (count=2; count < prim; count++)//用于统计循环次数，除数


算到 prim 的平方根就可以了。

引用 17 楼 卖水果的net 的回复:

算到 prim 的平方根就可以了。

是的。

不仅仅是第一段程序的 count 只要 <sqrt(prime)，而且只要遍历已经找出过的素数就可以了，完全不必 count++ 遍历。

总的来说第一种方式耗费比较大，需要优化的地方多一些。而第二种方式（筛法）中有些小的优化则不必太在意因为耗费微乎其微。

窃以为，从2除到int根号n，是不是可以快一点

引用 17 楼 卖水果的net的回复:

                for (count=2; count < prim; count++)//用于统计循环次数，除数


算到 prim 的平方根就可以了。

对。我这个遍历的范围有点广

引用 24 楼 weixin_44626304的回复:

Quote: 引用 17 楼 卖水果的net的回复:

                for (count=2; count < prim; count++)//用于统计循环次数，除数


算到 prim 的平方根就可以了。

对。我这个遍历的范围有点广

谢谢您。也谢谢楼上的伙伴们大力的帮助。谢谢您们

for (i = 2, j = 3; i <= sqrt(100); i = j += 2)

楼上范围错了
for (i = 2, j = 3; i <= 100; i = j += 2) 

还有用筛法 不过100以内效率差不多

欧拉线性筛了解一下

素数筛，O(n)算法，最快的吧

#include"cstdio"  
#include"cstring"  
using namespace std;  
#define MAX 100000//求MAX范围内的素数  
long long su[MAX],cnt;  
bool isprime[MAX];  
void prime()  
{  
    cnt=1;  
    memset(isprime,1,sizeof(isprime));//初始化认为所有数都为素数  
    isprime[0]=isprime[1]=0;//0和1不是素数  
    for(long long i=2;i<=MAX;i++)  
    {  
        if(isprime[i])  
            su[cnt++]=i;//保存素数i  
        for(long long j=1;j<cnt&&su[j]*i<MAX;j++)  
        {  
            isprime[su[j]*i]=0;//筛掉小于等于i的素数和i的积构成的合数  
        }  
    }  
}  
int main()  
{  
    prime();  
    for(long long i=1;i<cnt;i++)  
        printf("%d  ",su[i]);  
    return 0;  
}

引用 30 楼 砸死牛顿的苹果 的回复:

还有用筛法 不过100以内效率差不多

最好写一个测试程序，贴结果数据。

有些优化是否真的值得，其实还是要用测试来验证。例如

筛[i] = true;

改为

if(!筛[i])

    筛[i]=true;

这类操作。

所以对于不太明显的所谓“优化”，对于那些可读性不好的所谓算法，其实可以先不使用。

学习，只要从2到max/2就行

vc++，我来试试

#include <stdio.h>
#include<math.h>
int main()
{
int k,i,j;
for(i=2;i<=100;i++)
{  k=sqrt(i);
   for(j=2;j<=k;j++)
   if(i%j==0) break;
   if(j>k) printf("%d\n",i);
}
   return 0;
}

引用 14 楼 desperaso 的回复:

public static bool IsPrime(int i)
        {
            return !Regex.IsMatch(new string('*', i), "^.?$|^(..+?)\\1+$");
        }

引用链接英文

引用

https://geelaw.blog/entries/regex-prime-js-benchmark/

中文（见评论）

引用

https://github.com/jawil/blog/issues/20

下面是大神对这个正则式的评论
您首先要意识到的是，判断质数属于 P，用正则表达式的方法是 指数级别 的算法，即使不用那个 高明 的 P 算法，也可以用 sqrt(N) 的方法，同样比正则表达式具有更优的 渐近时间复杂度。

其次，您的实现是不公平的，正则表达式版本缺少对 num 的检验，循环的版本里面开方会面临浮点误差的问题。对于开方的问题，一种常见的实现是换成 i*i<=x（实践上性能也更好），另一种是把开方结果四舍五入。

最后，您测量时间的 方法是错误的，因为：

    您忘了考虑第一次 JIT 时间混进来；
    您并没有测试多次取平均数（当然这里也要小心编译器发现这些函数是纯粹的，从而优化掉）；
    您的数据很糟糕——123456 具有一个非常非常小的质因子。

我重新写了一份代码。先贴结果，我的环境是 NodeJS 6.10.3，多次运行结果接近这种排序：

isPrimeSqrtN(19): 0.154ms
isPrimeRegex(19): 0.161ms
isPrimeSqrtN(123456): 0.460ms
isPrimeRegex(123456): 2.868ms
isPrimeSqrtN(347*347): 0.581ms
isPrimeRegex(347*347): 30.239ms

测试的命令是 node <file.js> 2> nul，测试的代码是（347 是一个质数）：

function isPrimeSqrtN(x)
{
    if (x < 2) return false;
    for (var i = 2; i * i <= x; ++i)
        if (x % i == 0)
            return false;
    return true;
}
function isPrimeRegex(x)
{
    return !/^1?$|^(11+?)\1+$/.test(Array(x+1).join('1'));
}

console.error(isPrimeSqrtN(9));
console.error(isPrimeSqrtN(7));
console.error(isPrimeRegex(9));
console.error(isPrimeRegex(7));

console.time('isPrimeSqrtN(19)');
console.error(isPrimeSqrtN(19));
console.timeEnd('isPrimeSqrtN(19)');
console.time('isPrimeRegex(19)');
console.error(isPrimeRegex(19));
console.timeEnd('isPrimeRegex(19)');

console.time('isPrimeSqrtN(123456)');
console.error(isPrimeSqrtN(123456));
console.timeEnd('isPrimeSqrtN(123456)');
console.time('isPrimeRegex(123456)');
console.error(isPrimeRegex(123456));
console.timeEnd('isPrimeRegex(123456)');

console.time('isPrimeSqrtN(347*347)');
console.error(isPrimeSqrtN(347*347));
console.timeEnd('isPrimeSqrtN(347*347)');
console.time('isPrimeRegex(347*347)');
console.error(isPrimeRegex(347*347));
console.timeEnd('isPrimeRegex(347*347)');