C#筛法求出范围内的所有质数

    科普篇:筛法是一种简单检定素数的算法。据说是古希腊的埃拉托斯特尼(Eratosthenes,约公元前274~194年)发明的,又称埃拉托斯特尼筛法(sieve of Eratosthenes).

说实话,之前我在求质数的场合都是验证某一数是否为质数的,用定义求即可方便的得出结论,代码如下:

01:  public static bool IsPrime(int n)
02:  {//判断n是否是质数
03:      if (n < 2) return false;
04:      for (int i = n - 1; i > 1; i--)
05:      {//n除以每个比n小比1大的自然数
06:          if (n % i == 0)
07:          {//如果有能被整除的,则不是质数
08:              return false;
09:          }
10:      }//否则则为质数
11:      return true;
12:  }

但是用这种方法的话,如果要求两个数x和y之间的所有质数,就要用循环判断:

1:  for (int i = x; i < y; i++)
2:  {
3:      if (IsPrime(i))
4:      {
5:          Console.Write(i);
6:      }
7:  }
今天翻书偶然看到了筛法可能更加适合处理这样的问题--求某上限内的所有质数:
01:  private static List<int> GenPrime(int j)
02:  {
03:      List<int> ints=new List<int>();
04:      BitArray bts=new BitArray(j+1);
05:      for (int x = 2; x < bts.Length / 2; x++)
06:      {
07:          for (int y = x + 1; y < bts.Length; y++)
08:          {
09:              if (bts[y] == false && y % x == 0)
10:              {
11:                  bts[y] = true;
12:              }
13:          }
14:      }
15:      for (int x = 2; x < bts.Length; x++)
16:      {
17:          if (bts[x] == false)
18:          {
19:              ints.Add(x);
20:          }
21:      }
22:      return ints;
23:  }

不过如果要求范围内质数的话也需要求两个范围的差集:

1:  List<int> ListResult = GenPrime(x).Except(GenPrime(y)).ToList();

之后又在另一篇高手的博客中发现了一篇线性的筛法算法,我将之改为了C#代码:
01:  private static List<int> GenPrime1(int x)
02:  {
03:      int num_prime = 0;
04:      List<int> ints = new List<int>();
05:      BitArray isNotPrime = new BitArray(x);
06:      for (int i = 2; i < x; i++)
07:      {
08:          if (!isNotPrime[i])
09:          {
10:              ints.Add(i);
11:              num_prime++;
12:          }
13:          for (int j = 0; j < num_prime && i * ints[j] < x; j++)
14:          {
15:              isNotPrime[i * ints[j]] = true;
16:              if (!Convert.ToBoolean(i % ints[j]))
17:                  break;
18:          }
19:      }
20:      return ints;
21:  }
传送到原帖:一般筛法求素数+快速线性筛法求素数
PS.第一次写博客,如有不足的地方请告诉我,我一定改!

时间: 2024-10-11 03:51:34

C#筛法求出范围内的所有质数的相关文章

用筛法求之N内的素数。

题目描述 输入 N 输出 0-N的素数 样例输入 100 样例输出 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 代码:#include<stdio.h>#include<math.h>int main(){    int a[200],n,i,j,k;      scanf("%d",&n);    for(i=1;i<n+1;i++)       a

Spark:求出分组内的TopN

制作测试数据源: c1 85 c2 77 c3 88 c1 22 c1 66 c3 95 c3 54 c2 91 c2 66 c1 54 c1 65 c2 41 c4 65 spark scala实现代码: import org.apache.spark.SparkConf import org.apache.spark.sql.SparkSession object GroupTopN1 { System.setProperty("hadoop.home.dir", "D:

codevs:1313 质因数分解:已知正整数 n是两个不同的质数的乘积,试求出较大的那个质数 。

#include<iostream>#include<cstdio>#include<cmath>using namespace std;int a[2];int main(){ int p,b=0; scanf("%d",&p); for(int i=2;i<=p/2;i++) { if(p%i==0) { printf("%d",p/i); return 0; } }}

孪生素数(用筛法求素数)

所谓孪生素数指的就是间隔为 2 的相邻素数,它们之间的距离已经近得不能再近了, 就象孪生兄弟一样.最小的孪生素数是 (3, 5), 在 100 以内的孪生素数还有 (5, 7), (11, 13), (17, 19), (29, 31), (41, 43), (59, 61) 和 (71, 73),总计有 8 组. 但是随着数字的增大,孪生素数的分布变得越来越稀疏,寻找孪生素数也变得越来越困难. 那么会不会在超过某个界限之后就再也不存在孪生素数了呢? 孪生素数有无穷多对!这个猜想被称为孪生素数猜

POJ 2689 - Prime Distance - [筛法求素数]

题目链接:http://poj.org/problem?id=2689 Time Limit: 1000MS Memory Limit: 65536K Description The branch of mathematics called number theory is about properties of numbers. One of the areas that has captured the interest of number theoreticians for thousan

筛法--求1到100的所有素数

用筛法求出100以内的全部素数,并按每行五个数显示 从1开始每次判断一个数是否为素数,如果为素数,就把所有能被这个数整除的数排除,即不是素数 首先是一个判断素数的函数 1 bool sushu(int x) 2 { 3 if (x==2) 4 return true; 5 for (int i = 2;i <= sqrt(x);i++) 6 { 7 if (x%i==0) 8 return false; 9 } 10 return true; 11 } 把能被素数整除得数排除 1 for (in

筛法求素数

筛法求素数,寻找素数最经典快速的方法!!! 用筛法求素数的基本思想是: 把从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 1

JD 题目1040:Prime Number (筛法求素数)

OJ题目:click here~~ 题目分析:输出第k个素数 贴这么简单的题目,目的不清纯 用筛法求素数的基本思想是:把从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的

筛法求素数的最优算法+解释

筛法求素数: 求n内的素数.先用2去筛,即把2留下,把2的倍数剔除掉:再用下一个质数,也就是3筛,把3留下,把3的倍数剔除掉:接下去用下一个质数5筛,把5留下,把5的倍数剔除掉:不断重复下去……. 由此,我们可以写出基础版的筛法求素: const int maxn = 102410240; bool isp[maxn]; void init() { memset(isp, true, sizeof(isp)); isp[0] = isp[1] = false; const int max1 =