筛法求素数
C语言数组编程题及解答
C语言数组编程题及解答【程序1】用筛选法求100之内的素数筛选法又称筛法，是求不超过自然数N（N>1）的所有质数的一种方法。
据说是古希腊的埃拉托斯特尼（Eratosthenes，约公元前274～194年）发明的，又称埃拉托斯特尼筛子。
具体做法是：先把N个自然数按次序排列起来。
1不是质数，也不是合数，要划去。
第二个数2是质数留下来，而把2后面所有能被2整除的数都划去。
2后面第一个没划去的数是3，把3留下，再把3后面所有能被3整除的数都划去。
3后面第一个没划去的数是5，把5留下，再把5后面所有能被5整除的数都划去。
这样一直做下去，就会把不超过N的全部合数都筛掉，留下的就是不超过N的全部质数。
因为希腊人是把数写在涂腊的板上，每要划去一个数，就在上面记以小点，寻求质数的工作完毕后，这许多小点就像一个筛子，所以就把埃拉托斯特尼的方法叫做“埃拉托斯特尼筛”，简称“筛法”。
#include <stdio.h>#include <math.h>void main(){int i,j;int a[100];for(i=0;i<100;i++)a[i]=i+1;for(i=1;i<100;i++){if(a[i]==0)continue;for(j=i+1;j<100;j++)if(a[j]%a[i]==0)a[j]=0;}for(j=1;j<100;j++) //j从1开始，去除a[0]（其值为1），因为1既不是质数，也不是合数if(a[j]!=0)printf("%d,",a[j]);printf("\n");}【程序2】题目：一个数如果恰好等于它的因子之和，这个数就称为“完数”。
例如6=1＋2＋3.编程找出1000以内的所有完数。
程序源代码：#include <stdio.h>int main(){int k[10];int i,j,n,s;for(j=2;j<1000;j++){n=-1;s=j;for(i=1;i<j;i++){if ((j%i)==0){n++;s=s-i;k[n]=i;}}if(s==0) //说明是完数{printf("%d is a wanshu:",j);for(i=0;i<=n;i++)printf("%d ",k[i]);printf("\n");}}return 1;}【程序3】题目：用选择法对10个数进行从大到小排序1.程序分析：可以利用选择法，即从后9个比较过程中，选择一个最小的与第一个元素交换，下次类推，即用第二个元素与后8个进行比较，并进行交换。
埃拉托斯特尼筛法
埃拉托斯特尼筛法
埃拉托斯特尼筛法，又称为素数筛法，是一种用于查找、标记所有小于或等于某个数字n的素数的算法。
该算法是著名古希腊数学家埃拉托斯特尼提出的，是现今仍用于素数的概念的基础。
1）首先，应该创建一个长度为n的bool型数组，该数组包含每一个数字的状态。
这里，用0表示素数，1表示非素数。
2）从2开始，遍历每个数字，判断其是否为素数，如果是素数，则标记其所有倍数的状态都为非素数，即将其倍数的状态由0变为1，例如将4、6、8、10状态改为非素数状态。
3）当已遍历完所有数字之后，状态为0的数就都是素数了。
这一算法具有时间复杂度O(n)，空间复杂度O(n)，是相对理想的素数算法。
在实际应用中，有另一种改进算法叫‘筛素数算法’，在此基础上加入了一步优化，使得算法的时间复杂度从O(n)降低到O(nloglogn)。
大素数筛法 -回复
大素数筛法-回复大素数筛法（也称为厄拉多塞筛法）是一种用于筛选素数的高效算法。
它使用了一种简单而有趣的方法，通过筛除非素数的倍数来逐渐找出所有的素数。
在这篇文章中，我们将一步一步地讲解大素数筛法的原理和实现过程。
首先，让我们来回顾一下什么是素数。
素数是指只能被1和它本身整除的数，例如2、3、5、7等。
素数在数论和密码学等领域具有重要的应用，因此求素数一直是数学家和计算机科学家们感兴趣的问题。
大素数筛法的基本思想是从2开始，将所有倍数都标记为非素数，然后继续找到下一个未被标记的数，重复这个过程，直到筛选完成。
下面我们将一步一步地演示这个算法：1. 首先，我们需要确定一个上限N，以确定需要筛选的素数范围。
我们将从2到N的所有数都视为候选数。
2. 创建一个布尔数组isPrime，其长度为N+1。
开始时，将数组中的所有元素都设置为true，表示它们都是素数的候选者。
3. 从2开始，将所有2的倍数（除了2本身）标记为非素数。
然后，再找到下一个未被标记的数，即3，将所有3的倍数（除了3本身）标记为非素数。
4. 接下来，找到下一个未被标记的数，即5，将所有5的倍数（除了5本身）标记为非素数。
我们继续这个过程，直到筛选到√N为止。
5. 最后，遍历isPrime数组，将所有仍然标记为true的数添加到一个结果数组中，这些数就是素数。
现在，我们来使用一个具体的例子来说明大素数筛法的执行过程。
假设我们想要找出小于或等于30的所有素数。
首先，我们将确定上限N为30，并创建一个长度为31的布尔数组isPrime。
接下来，我们将从2开始，将所有2的倍数（除了2本身）标记为非素数。
在isPrime数组中，我们将2的倍数6、10、14、18、22、26和30都设置为false。
继续寻找下一个未被标记的数，即3。
将所有3的倍数（除了3本身）标记为非素数。
在isPrime数组中，我们将3的倍数9、15、21、27都设置为false。
第十一讲 初等数论-2
12
• 分析： 分析：
–先明确下各个变量代表的意思： 先明确下各个变量代表的意思： 先明确下各个变量代表的意思
• x：青蛙A的出发点坐标 青蛙A • y：青蛙B的出发点坐标 青蛙B • m：青蛙A一次能跳m米 青蛙A一次能跳m • n：青蛙B一次能跳n米 青蛙B一次能跳n • L：纬度线总长L米 纬度线总长L
2
gcd（最大公因子） 最大公约数 gcd（最大公因子）
• Euclidean算法求两个正整数a和b的 Euclidean算法求两个正整数a 算法求两个正整数 gcd。先令r gcd。先令r0为a，r1为b，接着执行如 下运算： 下运算：
3
最大公约数
• GCD递归定理：对任意非负整数a和任意 GCD递归定理 对任意非负整数a 递归定理： 正整数b 正整数b，gcd(a, b) = gcd(b, a mod b)。 b)。
7
扩展欧几里德算法
程序代码如下： 程序代码如下： int extended_ gcd(int a, int &y){ int t, gcd; if (b == 0) { x = 1; y = 0; return a; } gcd = extended_ gcd t = x; x = y; y = t return gcd; } int b, int &x,
14
第三章
同 余
同余是数论中的重要概念， 同余是数论中的重要概念，同余理论是研究整数 问题的重要工作之一.本章介绍同余的基本概念， 问题的重要工作类和完全剩余系.
15
例3. 求 7 的个位数.
7 解：1 ≡ −3(mod10), 7 2 ≡ −1(mod10), 7 4 ≡ 1(mod10)
埃氏筛质数
埃氏筛质数埃氏筛法也称作埃拉托色尼筛法，是一种数学方法，用于计算素数。
这种方法最初由古希腊数学家埃拉托色尼发明，现在被广泛应用于计算机科学和数学中。
它的核心思想是通过排除不是素数的数字，来确定素数的集合。
这个方法非常简单直观，但对于大数和高效的实现方法需要一定的技巧和优化。
埃氏筛法的实现方式是从2开始，逐一遍历所有的数字，并标记其所有的倍数为非素数，也就是合数。
当所有的数字都被遍历完成后，代表没有被标记的所有数字都是素数。
这种方法的核心代码如下：```def sieve_of_eratosthenes(n):primes = [True] * nprimes[0] = primes[1] = Falsefor i in range(2, int(n ** 0.5) + 1):if primes[i]:for j in range(i * i, n, i):primes[j] = Falsereturn [i for i in range(n) if primes[i]]```在这个代码中，我们首先初始化一个大小为n的质数列表，并将所有的值都初始化为True。
接着，我们将0和1标记为非素数。
然后从2开始，遍历所有小于n的数字，当我们遇到一个素数时，我们就将其所有的倍数都标记为非素数。
在这个遍历的过程中，我们可以使用一个优化技巧，也就是只标记比当前数大，其倍数之前没有被标记过的数字。
这个优化可以大大减少不必要的计算，提高程序的运行效率。
另外，我们在循环遍历中，也可以将遍历的结束条件限制在小于根号n，这是因为如果遍历到大于根号n的数时，其倍数一定已经在之前被标记过了。
在完成标记过程后，我们只需要遍历所有的数字，将未被标记的数字加入到素数集合中即可。
这个算法的时间复杂度是O(nloglogn)，空间复杂度是O(n)，虽然有许多优化筛法可以进一步的降低时间复杂度，但在实践中，埃氏筛法已经足够快和简单了，除非需要处理非常大的素数集合，否则不需要使用更高级的算法。
用筛法求出100以内的全部素数
例6、用筛法求出100以内的全部素数，并按每行五个数显示。
【问题分析】⑴把2到100的自然数放入a[2]到a[100]中（所放入的数与下标号相同）；⑵在数组元素中，以下标为序，按顺序找到未曾找过的最小素数minp,和它的位置p（即下标号）；⑶从p+1开始，把凡是能被minp整除的各元素值从a数组中划去（筛掉），也就是给该元素值置0；⑷让p=p+1，重复执行第②、③步骤，直到minp>Trunc(sqrt(N)) 为止；⑸打印输出a数组中留下来、未被筛掉的各元素值，并按每行五个数显示。
用筛法求素数的过程示意如下（图中用下划线作删去标志）：① 2 3 4 5 6 7 8 9 10 11 12 13 14 15…98 99 100 ｛置数｝② 2 3 4 5 6 7 8 9 10 11 12 13 14 15…98 99 100 {筛去被2整除的数}③ 2 3 4 5 6 7 8 9 10 11 12 13 14 15…98 99 100 {筛去被3整除的数}……2 3 4 5 6 7 8 9 10 11 12 13 14 15…98 99 100 {筛去被整除的数}Program Exam53;const N=100;type xx=1 .. N; {自定义子界类型xx（类型名）}Var a: array[xx] of boolean; i,j: integer;BeginFillchar(a,sizeof(a),true);a[1] := False;for i:=2 to Trunc(sqrt(N)) doif a[I] thenfor j := 2 to N div I doa[I*j]:= False;t:=0;for i:=2 to N doif a[i] thenBeginwrite(a[ i ]:5); inc(t);if t mod 5=0 then writelnend;End.【例3】输入十个正整数，把这十个数按由大到小的顺序排列（将数据按一定顺序排列称为排序，排序的算法有很多，其中选择排序中的“简单选择排序”是一种较简单的方法）分析：要把十个数按从大到小顺序排列，则排完后，第一个数最大，第二个数次大，……；因此，我们第一步可将第一个数与其后的各个数依次比较，若发现，比它大的，则与之交换，比较结束后，则第一个数已是最大的数。
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.首先，我们需要一个布尔数组来存储小于等于上限的数是否为素数。
线性筛法求素数的原理与实现
何为线性筛法，顾名思义，就是在线性时间内（也就是O（n））用筛选的方法把素数找出来的一种算法，没用过线性筛素数法的人可能会奇怪，用遍历取余判定素数不是也是线性时间的吗，没错，但是确切的说线性筛法并不是判定素数的，而是在线性时间内求出一个素数表，需要判定是否是素数的时候只要看该数是否在表内就可以瞬间知道是不是素数。
比如想求10000以内的素数，定义表int a[10000]，进行线性筛选后，a[n]的值就代表n是不是素数，a[n]如果是1，就代表n是素数，a[n]如果是0，就代表n不是素数，这就是查表。
再判定其他的素数也是一样，不用再做任何计算。
而如果用遍历取余，那么每判定一个数都要从头开始再遍历一遍，而线性筛法只在开始一次性运算完，以后只要查表即可，查表通常只需要1条语句。
所以如果你的程序从始至终只需要判定那么几次素数那么用遍历取余即可，但是如果需要多次判定素数，而且这个数还不是很小的话，那么线性筛法就会体现出巨大的优越性来。
线性筛法的核心原理就是一句话：每个合数必有一个最大因子（不包括它本身），用这个因子把合数筛掉，还有另一种说法（每个合数必有一个最小素因子，用这个因子筛掉合数，其实都一样，但是我觉得这种方法不太容易说明，这种方法我会在最后给出简略说明）。
这个很容易证明：这个小学就知道合数一定有因子，既然是几个数，就一定有最大的一个。
最大因子是唯一的，所以合数只会被它自己唯一的因子筛掉一次，把所有合数筛掉后剩下的就全是素数了。
先假设一个数i，一个合数t，i是t最大的因数，t显然可能并不唯一（例如30和45的最大因数都是15）。
那么如何通过i知道t呢，t必然等于i乘以一个比i小的素数。
先来说这个数为什么一定要比i小，这很显然，如果是i乘上一个比它大的素数，那么i显然不能是t最大的因子。
再来说为什么要是素数，因为如果乘上一个合数，我们知道合数一定可以被分解成几个素数相乘的结果，如果乘上的这个合数x=p1*p2*……，那么t = i * x = i * p1 * p2……很显然p1* i也是一个因数，而且大于i。
素数的算法原理和应用
素数的算法原理和应用概述素数是指只能被1和自身整除的正整数。
素数在密码学、计算机科学和数学研究等领域具有重要的应用。
本文将介绍素数的算法原理以及在实际应用中的一些常见场景。
素数的判断算法判断一个数是否为素数是素数算法的基础。
常用的素数判定算法有两种：试除法和素数筛法。
试除法试除法是最简单直观的素数判定方法。
对于一个待判断的正整数n，只需从2开始遍历到sqrt(n)（即n的平方根）的整数m，检查是否有任何m能整除n。
若能找到能整除n的m，则n不是素数；否则，n是素数。
试除法的时间复杂度为O(sqrt(n))，适用于判断大部分整数是否是素数。
然而，对于非常大的数，这种方法的效率较低。
素数筛法素数筛法通过筛选法来判断素数。
其中最常用的是埃拉托斯特尼筛法。
首先，生成一个长度为n+1的布尔类型数组，将其初始值都设为true。
然后从2开始遍历到sqrt(n)的整数m，在数组中将2的倍数、3的倍数、4的倍数…全部标记为false。
最后，数组中值为true的索引对应的数就是素数。
素数筛法的时间复杂度为O(nloglogn)，虽然比试除法高效，但由于需要生成一个长度为n+1的数组，对于非常庞大的数，也存在一定的限制。
素数的应用素数在密码学、计算机科学和数学研究等领域有广泛的应用。
以下是一些常见的素数应用场景。
密码学中的应用素数在密码学中起到至关重要的作用，特别是在公钥密码学中。
其中一个常见的应用是RSA加密算法。
在RSA算法中，首先需要生成两个大素数p和q，然后计算它们的乘积n=p*q。
n被用作加密和解密过程中的模数，而p和q用于生成公钥和私钥。
素数的随机性应用素数的随机分布属性使其成为生成随机数的重要组成部分。
例如，质数的随机分布性质被广泛应用在随机数生成算法中，确保生成的随机数能够满足安全性和随机性的要求。
整数因子分解素数在整数因子分解中也有重要应用。
由于素数只能被1和自身整除，因此在将一个大数分解成其因子时，可以使用素数的概念来加快计算过程。
ACM 筛素数总结
【总结】关于求素数的说【两种筛法】（学习小结，请无视）素数大家都很熟了，不多说了，这里只想说一下求素数。
当然先是唯一素因子分解定理：合数a仅能以一种方式，写成如下的乘积形式：a=p1e1p2e2…prer其中pi为素数，p1<p2<…<pr，且ei为正整数对于一个整数n，当其在小于sqrt（n）范围里有一个约数，那么必然在大于sqrt（n)的范围里有对应的另一个Eratosthenes（埃拉托斯特尼筛法）都是到sqrt（n）的范围。
①。
试除法判素数对于大于1的正整数a，如果a具有小于或等于sqrt（a）的素因子，则a为合数，否则a为素数。
因此，可用区间[2,sqrt(a)]内的数去试除a，只要有一个数能整除a ，则a为合数，否则a为素数。
这种判断素复杂度O(sqrt(n)).IsPrime(a)for(i=2;i*i<=a;i++)if(a%i==0)return a为合数return a为素数②。
Sieve Of Eratosthenes（埃拉托斯特尼筛法）可以筛出2~n 范围里的所有素数。
1)将所有候选数2~n放入筛中;2)找出筛中最小数P，P一定为素数。
3)宣布P为素数，并将P的所有倍数从筛中筛去;4)重复2)至3)直到筛空.其实，当P>sqrt(n)时筛中剩下的数就已经都是素数了。
//用数组prime[MAXN]记录是否为素数；//prime[i]为0表示i为素数，否则为合数int prime[MAXN]={0};for(i=2;i*i<=n;i++){if(prime[i]==0){for(j=i+i;j<=n;j+=i)prime[j]=1;}}③。
线性筛法对于Sieve Of Eratosthenes，普通的筛法如果是一个合数，那么会被多次筛掉，比如6,当2作为素数时筛掉一线性筛法保证所有合数只被筛掉一次具体详见《ftfish利用积性函数的优化》，讲到了积性函数（对于正整数n的一个算术函数f(n)，当中f(1)=1且称它为积性函数。
素数题目解答
yes
19
no
20
yes
5
1、筛法求素数
const int N=1e5+10; bool a[N]; int main(){
a[0]=a[1]=1; for(int i=2;i*i<=N;i++){
if(!a[i]){ for(int j=i*i;j<=N;j+=i) a[ j]=1;
} } scanf("%d",&n); for(int i=0;i<n;i++){
输出：
所有小于等于n的素数对。每对素数对输出一行，中间用单个空格隔开。若没
有找到任何素数对，输出empty。 样例输入 100
样例输出 35 57
11 13
17 19
29 31
41 43
59 61
71 73ຫໍສະໝຸດ 2、素数对#include<iostream> #include<cstdio> using namespace std; const int N=1e6+10; int a[N]; int main(){
3、判断素数的个数
#include<iostream> #include<cstdio> using namespace std; const int N=1e6+10; int a[N]; int main(){
int n,m,b=0; a[0]=a[1]=1; for(int i=2;i*i<=N;i++){
4、回文素数
#include<bits/stdc++.h> using namespace std; int huiwen(int i){
素数筛法算法及其原理
素数筛法算法及其原理引⾔本⽂介绍部分素数筛法的步骤以及原理，并附带 python 算法的实现本⽂介绍的筛法有：厄拉多塞筛法（Eratosthenes Sieve ）Sundaram 筛法欧拉筛法（Euler Sieve ）分段筛法（Segmented Sieve ）增量筛（Incremental sieve ）Atkin 筛法厄拉多塞筛法（Sieve of Eratosthenes ）1. 厄拉多塞筛法步骤给定⼀个数 n，从 2 开始依次将 √n 以内的素数的倍数标记为合数标记完成后，剩余未被标记的数为素数（从 2 开始）算法原理如下：读取输⼊的数 n ，将 2 ⾄ n 所有整数记录在表中从 2 开始，划去表中所有 2 的倍数由⼩到⼤寻找表中下⼀个未被划去的整数，再划去表中所有该整数的倍数重复第(3)步，直到找到的整数⼤于 √n 为⽌表中所有未被划去的整数均为素数2. 厄拉多塞筛法原理⾸先，先证明这种⽅法能够标记所有 2~n 之间的合数。
由整数的唯⼀分解定理知，任意⼀个⼤于1的正整数都可以被分解成有限个素数的乘积。
因此，任意⼀个合数都可以看做是⼀个素数的倍数的形式。
对于任意⼀个合数 n ，存在 p, q ，使得 n = p·q （不妨设 p 为素数）同时可有 min(p, q) ≤ p ≤ √n ，否则会有 p · q ≥ min(p, q)2 ＞ n ，⽭盾故可知，任意合数都能被不⼤于 √n 的素数 p 标记其次，显然，该标记⽅法并不会错误地将素数标记成合数故该⽅法能且仅能标记所有 2~n 之间的合数，所以剩下未被标记的数就是素数（从 2 开始）3. 厄拉多塞筛法代码from math import sqrtdef sieve_of_eratosthenes(n: int):is_prime = [True for _ in range(n + 1)]for i in range(2, int(sqrt(n)) + 1):if is_prime[i]:for j in range(i * i, n + 1, i):is_prime[j] = False # 筛去j# 返回从2开始未被筛去的整数return [i for i in range(2, n + 1) if is_prime[i]]在筛去素数 p 倍数的过程中，我们是从 p 2 开始，⽽不是从 2·p 开始之前厄拉多塞筛法的原理中提到过，任意合数都能被不⼤于 √n 的素数标记。
线性筛法求素数
线性筛法求素数
线性筛法是一种求素数的算法，它是埃拉托斯特尼筛法的简化版本。
其主要思想是：首先用2去筛，然后用3去筛，接下来用5去筛，依次类推，将不大于根号n的所有素数的倍数剔除，最后剩下的就是素数。
1.先把2到n之间的数字从小到大排列好，设定一个变量p等于2；
2.把2这个数字标记为素数，并把它的倍数都标记为非素数；
3.将变量p加1，如果变量p的值不大于根号n，则重复步骤2，否则将p的值作为素数；
4.重复步骤3，直到p的值大于根号n；
5.此时得到了从2到根号n之间的所有素数。
第七章C语言谭浩强答案
7.1用筛法求100之内的素数。
解：所谓“筛法”指的是“Eratosthenes筛法”。
Eratosthenes是古希腊的著名数学家。
他采用的方法是：在一张纸上写下1～1000之间的全部整数，然后逐个判断它们是否素数，找出一个非素数就把它挖掉，最后剩下的就是素数。
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 2728 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 …具体做法如下：先将1挖掉（因为1不是素数）。
用2去除它后面的各个数，把能被2整除的数（如4，6，8…）挖掉，即把2的倍数挖掉。
用3去除它后面各数，把3的倍数挖掉。
分别用4，5…各数作为除数去除这些数以后的各数。
这个过程一直进行到在除数后面的数已全被挖掉为止。
例如在上表中1～50范围内的素数，要一直进行到除数为47为止。
事实上，这一过程可以简化。
如果需要找1～n数）即可。
例如对1~50，只需进行到将7上面的算法可表示为：挖去1；用刚才被挖去的数的下一个数p去除p后面的各数，把p的倍数挖掉；检查p n=1000，则检查p<31否），如果是，则返回（2）继续执行，否则就结束；纸上剩下的就是素数。
解题的基本思路有了，但要变成计算机的操作，还要作进一步的分析。
如怎样判断一个数是否已被“挖掉”，怎样找出某一个数p的倍数，怎样打印出未被挖掉的数。
可以设一个数组a，a[1]到a[100]的值分别是1，2，3，…100。
然后用上述方法将非素数“挖去”。
如果一个数被认为是非素数，就将它的值变为零，最后将不为零的数组元素输出，就是所求的素数表。
程序如下：#include <math.h>main ( ){int i,j,n,a[101];for (i=1;i<=100;i++)a[i] =i;for (i=2;i<sqrt(100);i++)for (j=i+1;j<=100;j++){if (a[i]!=0 && a[j]!=0)if (a[j]%a[i]==0)a[j]=0; } /*非素数，赋值为0，“挖掉”*/printf(“\n”);for (i=2,n=0;i<=100;i++){ if (a[i]!=0){printf(“%5d”,a[i]);n++; }if (n==10) /*此处if 语句的作用是在输出10个数后换行*/{ printf (“\n”);n=0; }}}运行结果：2 3 5 7 11 13 17 19 23 29 31 37 41 4347 53 59 61 67 71 73 79 83 89 977.2用选择法对10个整数排序（从小到大）。
筛分法的原理
筛分法的原理筛分法，又称为素数筛法或埃拉托斯特尼筛法，是一种用于筛选素数的经典算法。
它的原理是通过不断排除合数，最终得到一系列素数。
该算法的核心思想是从2开始，将所有的整数进行标记，初始状态都为合数。
然后从小到大遍历这些整数，如果当前数字是素数（即未被标记），则将其倍数都标记为合数。
在遍历完所有的数之后，剩下的未被标记的数字即为素数。
具体实现时，可以使用一个布尔数组来记录每个数字的状态，初始时都设为true。
然后从2开始，将2的倍数都标记为false，然后继续遍历为true的下一个数字，将其倍数标记为false。
一直重复这个过程，直到遍历完所有的数字。
举个例子来说明筛分法的原理。
我们以找出100以内的素数为例。
首先，我们将2标记为素数，并将2的倍数4、6、8、...都标记为合数。
然后，我们继续遍历到下一个为true的数字3，将3的倍数6、9、12、...都标记为合数。
依次类推，我们将5、7、11等素数的倍数都标记为合数。
最终，剩下的未被标记的数字即为素数。
通过筛分法，我们可以高效地找出一定范围内的素数。
该算法的时间复杂度为O(nloglogn)，其中n为待筛选的范围。
相比于暴力判断每个数字是否为素数的方法，筛分法具有更高的效率。
筛分法不仅可以用于求解素数，还可以用于求解质数因子、约数个数等问题。
它在数论和密码学等领域有着重要的应用。
同时，筛分法的思想也可以启发我们解决其他问题，例如筛选特定条件的数、排除非法数据等。
总结起来，筛分法是一种高效的筛选素数的算法。
通过不断排除合数，最终得到一系列素数。
它的原理简单易懂，实现起来也相对较为简单。
在实际应用中，我们可以利用筛分法解决各种与素数相关的问题，提高算法效率。
c语言素数个数求法
c语言素数个数求法C语言是一种广泛应用于计算机编程的高级编程语言，它的语法简洁、灵活，并且具有较高的执行效率。
在C语言中，我们可以使用不同的算法来解决各种问题。
本文将介绍如何使用C语言编写一个求解素数个数的程序。
什么是素数呢？素数，又称质数，是指除了1和它本身之外，没有其他因数的自然数。
例如，2、3、5、7、11等都是素数。
求解素数个数的算法有很多种，我们这里介绍其中一种常用的方法——埃拉托斯特尼筛法（Sieve of Eratosthenes）。
埃拉托斯特尼筛法是一种简单而高效的筛法，它的基本思想是从2开始，将每个素数的倍数标记为合数，直到遍历完所有小于或等于给定数的自然数。
具体的实现步骤如下：1. 首先，我们需要定义一个布尔类型的数组prime[]，其中prime[i]的值表示数字i是否为素数。
初始化时，我们将所有元素都设置为true，即默认所有数字都是素数。
2. 然后，我们从2开始遍历数组prime[]。
对于每个素数i，我们将其所有的倍数（除了i本身）标记为合数，即将对应位置的prime[j]设置为false。
3. 遍历完所有小于或等于给定数的自然数后，我们统计数组prime[]中值为true的元素个数，即为素数的个数。
下面是使用C语言实现埃拉托斯特尼筛法求解素数个数的示例代码：```c#include <stdio.h>int countPrimes(int n) {int count = 0;int prime[n+1];// 初始化数组prime[]for (int i = 2; i <= n; i++) {prime[i] = 1;}// 埃拉托斯特尼筛法for (int i = 2; i * i <= n; i++) {if (prime[i] == 1) {for (int j = i * i; j <= n; j += i) {prime[j] = 0;}}}// 统计素数个数for (int i = 2; i <= n; i++) {if (prime[i] == 1) {count++;}}return count;}int main() {int n;printf("请输入一个整数n：");scanf("%d", &n);int num = countPrimes(n);printf("小于或等于%d的素数个数为：%d\n", n, num);return 0;}```在这段代码中，我们定义了一个函数`countPrimes()`来求解小于或等于给定数n的素数个数。
筛法求素数
具体做法是：先把N个自然数按次序排列起来。1不是质数，也不是合数，要划去。第二个数2是质数留下来，而把2后面所有能被2整除的数都划去。2后面第一个没划去的数是3，把3留下，再把3后面所有能被3整除的数都划去。3后面第一个没划去的数是5，把5留下，再把5后面所有能被5整除的数都划去。这样一直做下去，就会把不超过N的全部合数都筛掉，留下的就是不超过N的全部质数。因为希腊人是把数写在涂腊的板上，每要划去一个数，就在上面记以小点，寻求质数的工作完毕后，这许多小点就像一个筛子，所以就把埃拉托斯特尼的方法叫做“埃拉托斯特尼筛”，简称“筛法”。
<1> 先将1挖掉(因为1不是素数)。
<2> 用2去除它> 用3去除它后面的各数，把3的倍数挖掉。
<4> 分别用5…各数作为除数去除这些数以后的各数。
找素数的两种方法
找素数的两种⽅法⽅法⼀：根据特点直接找质数（prime number）⼜称素数，有⽆限个。
质数定义为在⼤于1的⾃然数中，除了1和它本⾝以外不再有其他因数。
根据这个性质，我们可以构造⼀个两层嵌套循环根据这个判断条件就可以找出1-n之间的素数了。
代码如下：#include<iostream>#include<cmath>using namespace std;int main() {//寻找素数的第⼀种⽅法bool isPrime;for (int i = 2; i < 100; i++) {isPrime = true;for (int j = 2; j < i; j++) {if (i%j == 0) isPrime = false;}if (isPrime) cout << i << " ";}return 0;}⽅法⼆：筛法求素数埃拉托斯特尼筛法，简称埃⽒筛或爱⽒筛，是⼀种由希腊数学家埃拉托斯特尼所提出的⼀种简单检定素数的算法。
要得到⾃然数n以内的全部素数，必须把不⼤于根号n的所有素数的倍数剔除，剩下的就是素数。
利⽤这个⽅法，我们可以建⽴⼀个从2到Math.sqrt(n)的循环，依次删除这些数的倍数。
代码如下：#include<iostream>#include<cmath>using namespace std;int main() {//寻找素数的第⼆种⽅法：埃拉托斯特尼筛⼦法，基本思路：不是挑选出所有素数，⽽是筛掉所有的合数。
int sum = 0, a[100] = { 0 };for (int i = 2; i < sqrt(100.0); i++) {sum = i;if (a[sum] == 0) {while (sum < 100) {sum += i;if (sum < 100) a[sum] = 1;}}}for (int i = 2; i < 100; i++) {if (a[i] == 0) cout << i << " ";}return 0;}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
筛法
筛法，是求不超过自然数N（N＞1）的所有质数的一种方法。
据说是古希腊的埃拉托斯特尼（Eratosthenes，约公元前274～194年）发明的，又称埃拉托斯特尼筛子。
具体做法是：先把N个自然数按次序排列起来。
1不是质数，也不是合数，要划去。
第二个数2是质数留下来，而把2后面所有能被2整除的数都划去。
2后面第一个没划去的数是3，把3留下，再把3后面所有能被3整除的数都划去。
3后面第一个没划去的数是5，把5留下，再把5后面所有能被5整除的数都划去。
这样一直做下去，就会把不超过N的全部合数都筛掉，留下的就是不超过N的全部质数。
因为希腊人是把数写在涂腊的板上，每要划去一个数，就在上面记以小点，寻求质数的工作完毕后，这许多小点就像一个筛子，所以就把埃拉托斯特尼的方法叫做“埃拉托斯特尼筛”，简称“筛法”。
（另一种解释是当时的数写在纸草上，每要划去一个数，就把这个数挖去，寻求质数的工作完毕后，这许多小洞就像一个筛子。
）
例如，用筛法找出不超过30的一切质数：
不超过30的质数2，3，5，7，11，13，17，19，23，29共10个。
使用pascal语言，利用筛法求素数的代码：
ReadLn(n);｛需要求2~n之间所有的素数｝
For i:=2 To n Do a := True;｛全部清成真，表示目前是素数｝
For i:=2 To n Do
If a Then｛当该数纪录是质数时开始筛选｝
For j:=1 To n Div i Do a[2 * j] := False;｛筛掉所有质数的倍数｝
sum := 0;｛统计范围内有多少个质数｝
For i:=2 To n Do
If a Then Begin｛如果是质数就输出｝
Write(i, ' ');
Inc(sum);
End;
WriteLn（sum）;｛输出总数｝
readln(n);(读入N);
for i:=2 to n do a[i]:=true;(先将a数组全部定义为素数,即用true代表素数,false 合数)
for i:=2 to trunc(sqrt(n)) do(1 to n 也可以,不过比较浪费时间)
begin
if a[i]=true then (如果这个数是素数,则执行.这样比较省时间)
begin
for j:=2 to n div i do
a[i*j]=false;(将一切可以被2、3、4...整除的数全部定义为合数)
end;。