前往小程序，Get更优阅读体验！
立即前往
文档建议反馈控制台
首页
学习
活动
专区
圈层
工具
MCP广场
文章/答案/技术大牛
发布
首页
学习
活动
专区
圈层
工具
MCP广场
返回腾讯云官网
社区首页 >专栏 >C语言素数优化方法

C语言素数优化方法

作者头像
CtrlX
发布于 2022-11-16 10:39:09
发布于 2022-11-16 10:39:09
3.2K00
代码可运行
举报
文章被收录于专栏：C++核心编程C++核心编程
运行总次数：0
代码可运行
关联问题
换一批

题目：求1~N范围中的素数。k为当前数值，j为被除数 素数：一个大于1的自然数中，除了1和本身外无法整除其余数的数值。

优化方法：

  • （除数去双）对于素数，可以忽略双数部分，因为均能被2整除，2也是素数做特殊情况，直接输出，即除去双数的可能，数据减少一半，即执行效率要提高一倍，k初始化为3，k+=2。
  • （被除数去双）因为k只可能为单数，所有被除数可忽略双数，被除数 j 初始化为3，每次 j += 2。
  • （开根）对于判断， 因为不是质数，那么一定可以表示成两个数（除了1和它本身）相乘，这两个数必然有一个小于等于它的平方根。只要找到小于或等于的那个就行了，用当前数值从3开始至当前数值的开根范围的数求余数，运行效率再次提高。
  • （判断）对于余数不等于0且 j 小于当前数值的开根值的情况，循环执行被除数 j += 2，若被除数 j 大于开根植，则当前数值为素数；对于余数==0的情况，表示不是素数。

具体实现代码：

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
#include <math.h>
#include <stdlib.h>

void get_prime(char *s)
{
	int N = atoi(s);
	int j = 3;
	double k = 3.0;//便于sqrt开根
	int n = 1;
	//2为特殊的素数
	printf("%d\t",2);
	//从3开始到N，依次找出素数
	while((int)k < N)
	{
		j = 3;
		//被除数小于当前数值的开根，且不能整数的情况
		while( j < sqrt(k) && ((int)k % j != 0) )
		{
			j += 2;//k不等于双数，被除数也可忽略双数部分数值
		}
		//如果一直到j大于开根值都不能整除则为素数
		if( j >= sqrt(k) )
		{
			printf("%d\t", (int)k);
			n++;
			if(n%5 == 0)
				printf("\n");
		}
		k += 2;
	}
	printf("\n");
}

int main(int argc, char **argv)
{
	printf("求1~%s的素数:\n",argv[1]);
	get_prime(argv[1]);
	return 0;
}

PS：

atoi (表示 ascii to integer)是把字符串转换成整型数的一个函数，应用在计算机程序和办公软件中。int atoi(const char *nptr) 函数会扫描参数 nptr字符串，会跳过前面的空白字符（例如空格，tab缩进）等。如果 nptr不能转换成 int 或者 nptr为空字符串，那么将返回 0 [1] 。特别注意，该函数要求被转换的字符串是按十进制数理解的。atoi输入的字符串对应数字存在大小限制（与int类型大小有关），若其过大可能报错-1。

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <iostream>
using namespace std;

bool prime(double m)//判断素数 
{
	int i = 0;
	if ((int)m == 0) return 0;
	if ((int)m == 1) return 0;
	if ((int)m == 2) return 1;
	for (i = 3; i <= sqrt(m); i += 2)
		if ((int)m % i == 0) return 0;

	if (i >= sqrt(m)) return 1;
	else return 0;
}

int main()
{

	double i = 3.0;
	cout << 2 << endl;
	for ((int)i ; i < 100; i+=2)
	{
		if (prime(i))
		{
			cout << i << endl;
		} 
	}

	system("pause");
	return 0;
}

问题

输出100以内的素数：

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <iostream>
#include <math.h>
using namespace std;

bool prime(int m) {
	int i = 0;
	if (m == 0) return 0;
	if (m == 1) return 0;
	if (m == 2) return 1;
	for (i = 3; i <= sqrt(m); i += 2)
		if (m % i == 0) return 0;

	if (i >= sqrt(m)&&i!=3) return 1;
	else return 0;
}

int main() {

	cout << 2 << endl;
	for (int i = 3; i < 100; i+=2)
	{
		if(prime(i)) cout << i << endl;
	}
	system("pause");
	return 0;
}

输出结果：缺失了3、5、7（即3-8以内的判断）（9之前的所有数开根号都小于i=3，所以出现了问题）

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
2
11
13
17
19
23
29
31
37
41
43
47
53
59
61
67
71
73
79
83
89
97
请按任意键继续. . .

优化：

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <iostream>
#include <math.h>
using namespace std;


bool prime(int m) {//解决了素数判断缺失前面几个数的问题
	int i = 0;
    if (m>= 0 && m <= 8){
        if(m==2 || m==3 || m==5 || m==7)return 1;
        else return 0;
    }
	for (i = 3; i <= sqrt(m); i += 2)
		if (m % i == 0) return 0;

	if (i >= sqrt(m)) return 1;
	else return 0;
}

int main() {

	cout << 2 << endl;
	for (int i = 3; i < 100; i+=2)
	{
		if(prime(i)) cout << i << endl;
	}
	system("pause");
	return 0;
}

输出结果：

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
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
请按任意键继续. . .

素数：又称质数，有无限个。一个大于1的自然数，除了1和它本身外，不能被其他自然数整除，换句话说就是该数除了1和它本身以外不再有其他的因数；否则称为合数。

如果要找出N以内的所有素数，大家都是这样想的：

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>

#define N 100

int main()
{
    int i,j;
    
    for(i = 2;i <= N;i++)
    {
        for(j = 2;j < i;j++)
        {
            if(i % j == 0)
            {
                break;        //找到因数，退出最里面的循环
            }
        }
        if(j == i)            //判断因素是不是自己本身
        {
            printf("%d ",i);
        }
    }
 
return 0;
}

像上面这样一个一个数的找过去，再查找因数，如果N是一个本大的数的话，这个耗时将是不可想像的，所以要对以上的算法进行优化一下。

1、缩小查找因素的范围

也就是缩小自变量是 j 的 for 循环，在查找因数的其实可以查找到（平方根+1）就可以了（+1是为了判断有没有整数的平方根，如果没有 j 就会运行到平方根+1，如果有，就会运行j 就会运行到平方根），所以现在可以把 j 的值局限到（平方根+1）：

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
#include <math.h>

#define N 100

int main()
{
	int i,j;
    for(i = 2;i <= N;i++)
    {
        for(j = 2;j < (int)sqrt(i) + 1;j++)
        {
            if(i % j == 0)
            {
                break;                //找到因数，退出最里面的循环
            }
        }
        if(j == (int)sqrt(i) + 1)     //判断因素是不是自己本身
        {
            printf("%d ",i);
        }
    }
 
return 0;
}

相对于一开始的那个方法，这个可以缩短了一段时间，不过当N足够大的时候，这个方法还是不可行的。

2、用数组标记素数

可以先创建一个大小是N + 1的数组，如果是素数就标记对应的值为0，不是素数对应的值就标记为1，等所有数据都判断完了再输出数组中的数据；

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
#include <math.h>

#define N 10000

int main()
{
	int i,j;
	int number[N + 1] = {0};        //是素数就保持为0，是合数就赋值为1
	

    for(i = 2;i <= (int)sqrt(N);i++)    
    {
        if(number[i] == 0)          //素数
        {
            for(j = i * i;j <= N;j += i)    //所有i的倍数都不是素数
            {
                number[j] = 1;
            }
        }
    }
    for(i = 2;i <= N;i++)
    {
        if(number[i] == 0)
        {
            printf("%d ",i);
        }
    }

return 0;

}

题目一：

请实现一个函数，对于给定的整型参数N，依次打印出小于N的素数。

解法一：试除法

由素数的定义我们很自然的会想到如下代码：

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>

void print_prime(int n)
{
	int i=0;
	for(i=2;i<=n;i++)
	{
		int j=0;
		for(j=2;j<i;j++)
		{
			if(0==i%j)
				break;	
		}
		if(j==i)
			printf("%d\t",i);
	}
}

int main()
{
	int num=0;
	scanf("%d",&num);
	print_prime(num);	
	return 0;
}

在上面的代码中，我们看到在判断素数时一直从2试除到n－1。这里从n／2之后的数到n－1的试除显然是多余的，比如某个数不能被3整除，必然不能被6整除。

优化1:

试除的范围优化到［2，n／2］，这样一下子就将工作量减少了一半，代码如下：

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
void print_prime(int n)
{
	int i=0;
	for(i=2;i<=n;i++)
	{
	        int j=0;
		for(j=2;j<=i/2;j++) //修改部分
		{
			if(0==i%j)
				break;	
		}
		
		if(j==(i/2+1))  //修改部分
			printf("%d\t",i);
	}
}

既然能将试除范围优化到［2，n/2］，那么这个范围是不是还能优化呢？答案是可以的，在［2，n/2］这个范围里（√n，n／2］的试除也是多余的。因为因数是成对出现的，比如16可分解为：1和16 、2和8、4和4、8和2、16和1。这些因数里必然有一个小于等于4。所以只需试除小于等于√n的数就可以了。

优化2:

试除范围优化为［2，√n］，代码如下：

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
#include <math.h>

void print_prime(int n)
{
	int i = 0;
	for (i = 2; i <= n; i++)
	{
		int j = 0;
		for (j = 2; j <= sqrt(i); j++) //修改部分
		{
			if (0 == i%j)
				break;
		}
		
		if (j >sqrt(i))         //修改部分
			printf("%d\t", i);
	}
}

int main()
{
	int num = 0;
	scanf("%d", &num);
	print_prime(num);
	return 0;
}

上面所有的代码在找素数的时候是从2到n，在这个范围内除了2之外的偶数都不是素数，所以我们可以跳过这些偶数。

还有试除范围内除了2之外的偶数也是没有必要的，因为如果不能被2整除，必然不能被大于2的偶数整除。

优化3：

寻找素数时跳过偶数、试除范围跳过除2之外的偶数。代码如下：

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
void print_prime(int n)
{
	int i = 0;
	if (n >= 2)         //修改部分
		printf("%d\t", 2);
		
	for (i = 3; i <= n; i+=2)   //修改部分
	{
		int j = 2;
		if(0==i%j)  //修改部分
		    break;
		    
		for (j = 3; j <= sqrt(i); j+=2) //修改部分
		{
			if (0 == i%j)
				break;
		}
		
		if (j >sqrt(i))
			printf("%d\t", i);
	}
}

其实在上面的代码中，试除范围内的一些数也是不必要的。比如判断101是否为素数时，要分别试除小于10的2和所有奇数，即2、3、5、7、9，其实对9的试除是不必要的。即对所有的非素数的试除是不必要的，因为非素数必然可分解为比它小的素数的乘积，既然它的质因数不能整除某个数，这个数必然也不能。故试除的范围可缩小到小于等于√n的所有素数。

优化4:

只试小于√n的素数

那么问题来了，要试除这些素数时必然要将前面求出的素数保存起来，开辟多大一块空间合适呢？因为n的大小未知，所以无法确定开辟多少空间。这里可以使用动态内存开辟空间，当空间不够时使用realloc()追加空间。

代码实现如下：

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define LEN 10 //每次开辟空间的大小

void  print_prime(int n)
{
	int *p = (int*)calloc(sizeof(int),LEN);
	if (p == NULL)
	{
		printf("out of memory !\n");
		exit(EXIT_FAILURE);
	}

	int i = 0, j = 1;
	int count = 1;

	if (n >= 2)  //第一个素数，输出并保存起来
	{
		printf("%d\t", 2);
		p[0] = 2;
	}

	for (i = 3; i <= n; i += 2)
	{
		int k = 0;
		while (p[k]>0 && p[k] <= sqrt(i))   //试除保存的素数
		{
			if (i%p[k] == 0)
				break;
			k++;
		}

		if (!p[k] || (p[k] > sqrt(i)))  //将新求出的素数保存起来
		{
			printf("%d\t", i);
			if (j >= (LEN*count))
			{
				count++;
				p = realloc(p, sizeof(int)*LEN*count);
				if(p==NULL)
				        exit(EXIT_FAILURE);
			}
			p[j] = i;
			j++;
		}

	}
	free(p);
}

int main()
{
	int num = 0;
	scanf("%d", &num);

	print_prime(num);

	return 0;
}

解法二：筛法

这种方法求素数的思想就是，不断筛去最小的数的倍数。这个最小的数必然是素数。

比如最小的素数是2，去掉所有2的倍数；接下来最小的数是3，3就是素数，去掉所有的3的倍数；依次类推，直到最小的数小于等于√n为止。为什么是√n呢？ 在上面的试除法中讲到只要试除小于等于√n的所有素数即可判断出小于等于n的所有素数，这里同样适用，只要去掉所有的小于等于√n的所有数的倍数，剩下的数就是小于等于n的所有素数。

代码如下：

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

void print_prime(int n)
{
	int *arr=(int*)malloc(sizeof(int)*n);
	if (arr == NULL)
	{
		printf("out of memory !\n");
		exit(EXIT_FAILURE);
	}
	int i = 0, j = 0;
	for (i = 0; i < n - 1; i++) //初始化数组［2，n］
	{
		arr[i] = i + 2;
	}
	while (arr[j] <= sqrt(n))  //除数的范围
	{
		for (i = j + 1; i < n - 1; i++)
		{
			if (arr[i] % arr[j] == 0)//筛去arr[i]的倍数
				arr[i] = 0;
		}
		j++;
		while (!arr[j])  //确定最小数
			j++;
	}

	for (i = 0; i < n - 1; i++)    //打印素数
	{
		if (arr[i])
			printf("%d\t", arr[i]);
	}
	free(arr);
}

int main()
{
	int num = 0;
	scanf("%d", &num);
	print_prime(num);
	return 0;
}

上面的代码有一个很明显的缺陷就是开辟的空间过大，如何来解决这个问题呢？

上面代码所开辟的空间为int型，占用空间太多，我们可以构造一个bool型数组，以下标来存储数据，这样就节省了75%的空间。

优化1：

构造bool型数组，以下标来存储数据,每个数只占一个字节。

代码如下：

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <math.h>


void print_prime(int n)
{
	bool *arr=(bool*)malloc(sizeof(bool)*n);
	if (arr == NULL)
	{
		printf("out of memory !");
		exit(EXIT_FAILURE);
	}
	int i = 0, j = 2;

	for (i = 0; i <= n; i++)//初始化数组为true
	{
		arr[i] = true;
	}

	while (j <= sqrt(n))    //除数的范围
	{
		for (i = j + 1; i <= n; i++)
		{
			if (i%j == 0)
				arr[i] = false;   //筛除
		}

		j++;
		while (!arr[j])    //寻找最小数
			j++;
	}

	for (i = 2; i <= n; i++)  //打印素数
	{
		if (arr[i])
			printf("%d\t", i);
	}
	free(arr);
}

int main()
{
	int num = 0;
	scanf("%d", &num);
	print_prime(num);

	return 0;
}

上面的代码使用bool类型占一字节来存储数据，想到这里，我们是不是可以用位来存储数据，一个字节有8位，每位节用bool值来表示这样空间利用率会大大的提高。

优化2:

构造定长的byte数组，用bit位存储数据

代码如下：

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
#include <stdlib.h>
#include <math.h>


//将ch的第position位  置0
unsigned char set_bit_0(unsigned char ch, int position)
{
	return ch  &  (~  ( (unsigned char)pow(2,  position)  )  );
}


//找arr指向的内存第position个位起，第一个不为0的比特位
int check_bit_1(int num,const unsigned char *arr, int pos)  
{
	
	while (pos<= num)
	{
		if ((  (arr[pos / 8] >> (pos % 8)   ) & 1) == 1)
			return pos;
		pos++;
	}
	return 0;
}


//求解素数
void print_prime(int n)
{
	unsigned char *arr = (unsigned char*)malloc(sizeof(unsigned char)*n / 8+1);
	if (arr == NULL)
	{
		printf("out of memory !\n");
		exit(EXIT_FAILURE);
	}
	
	int i = 0,j=2;
	
	for (i = 0; i < n/8+1; i++) //将bit数组置为全1
	{
		arr[i] = 0xff;
	}

	while (j <= sqrt(n)) //筛除范围
	{
		for (i = j + 1; i <= n; i++)
		{
			if (i%j == 0) //将非素数对应的位 置0
				arr[i / 8] = set_bit_0( arr[i / 8] , i % 8);
		}
		
		j++;
		j = check_bit_1(n,arr, j);
		if (j == 0)
			break;
	}
	
	for (i = 2; i <= n; i++)   //打印素数
	{
		i = check_bit_1(n,arr, i);
		if (i == 0)
			break;
		printf("%d\t", i);

	}


}

int main()
{
	int num = 0;
	scanf("%d", &num);
	print_prime(num);
	return 0;
}

题目二：

​ 从小到大依次打印N个素数

解法一：试除法

​ 经过题目一的求解优化，这里直接给出试除法优化的终极版：试除保存起来的素数。

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

void print_N_prime(int num)
{
	int count = 0;
	int i = 3,j=0,flag=2;
	int *arr = calloc(num,sizeof(int));
	
	if(arr==NULL)
	{
	        printf("out of memory !\n");
	        exit(EXIT_FAILURE);
	}
	
	arr[0] = 2; 
	count = 1;    //统计素数的个数
	
	while (count<num)
	{

		for (j = 0;  arr[j] <= sqrt(i) && arr[j] ;  j++)  //试除判断素数
		{
			if (i%arr[j] == 0)
				break;
		}

		if (arr[j] > sqrt(i))  
		{
			arr[count]=i;
			count++;
		}

		i++;
	}

	for (i = 0; i < count; i++)  //打印素数
	{
		printf("%d\t", arr[i]);
	}
}

int main()
{
	int n = 0;
	scanf("%d", &n);
	
	print_N_prime(n);

	return 0;
}

解法二：筛法

筛法需要容器，这个容器要多大呢？由素数定理可以近似求出素数的分布范围。如0～x中有x/lnx个素数，反推即可求出n个素数的分布范围，由于这只是近似，把容器再扩大30%，应该足够了。

求出范围后解法与题目一类似，只需在输出素数时控制输出个数即可。

本文参与 腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。
原始发表：2022-11-07，如有侵权请联系 cloudcommunity@tencent.com 删除
编程算法
存储

本文分享自 作者个人站点/博客 前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ，欢迎热爱写作的你一起参与！

编程算法
存储
评论
登录后参与评论
暂无评论
登录 后参与评论
推荐阅读
编辑精选文章
换一批
万字详解高可用架构设计
1477
Go 开发者必备：Protocol Buffers 入门指南
713
10分钟带你彻底搞懂分布式链路跟踪
384
多租户的 4 种常用方案
862
亿级月活的社交 APP，陌陌如何做到 3 分钟定位故障？
649
60页PPT全解：DeepSeek系列论文技术要点整理
1337
C语言如何判断素数及相关知识
return编程博客函数int
引言： 素数是指大于1且只能被1和自身整除的自然数。在C语言编程中，判断一个数是否为素数是一个常见的问题。本篇博客将向你介绍C语言中素数的相关知识，并给出代码示例来帮助你理解如何判断一个数是否为素数。
GG Bond1
2024/06/14
2.6K0
经典例题（一）——经典例题的归纳总结。
编程算法
这里，我们要先了解素数的定义，素数也叫质数 ，即在正整数中，除了1与本身之外没有其他约数的数（1除外）。 方法一： 也就是说，这个数只能被1和它本身整除。了解这一点后我们开始入手写代码，在这里我们最容易想到的方法就是试除法，即从2开始，不断地对那个数进行试除，假设这个数是n，直到试除到n（不包含n）为止，如果没有出现可以被整除的数，则n就是素数。
诺诺的包包
2023/02/17
5390
经典例题（一）——经典例题的归纳总结。
c语言必会题目
基础int遍历变量函数
代码讲解: 比如求24和18的最大公约数,我们可以使用辗转相除法来求,假设a,b,c三个变量,把被除数24赋值给a,把除数18赋值给b,相除的余数a%b赋值给c,经过一轮相除,我们可以知道余数为6,此时我们把b的值赋值给a,再把c赋值给b,在进行一轮相除,此时余数为0,我们再把b的值赋值给a,c的值赋值给b,而c等于0,此时b的值为两数的最大公约数,其本质就是让除数和余数辗转相除,直到余数为0,此时除数就是最大公约数.
用户11317877
2024/10/16
1040
C语言基础程序——入门经典100道实例
公众号基础入门算法程序
问题分析：先在百位数选择一个数字，接着在十位上选择一个数字，最后在个位上选择一个数字，但要保证每次选择的三个数字都互不相同，使用三个for循环即可找出这样的数字。
数据结构和算法
2024/10/29
5070
C语言基础程序——入门经典100道实例
C语言初阶小练习1（1.素数的打印，2.闰年的判断和打印,3.求解两个数的最大公约数）
int函数基础算法效率
"试除"，就是不断地尝试能否整除。比如要判断自然数 x 是否质数，就不断尝试小于 x 且大于1的自然数，只要有一个能整除，则 x 是合数；否则，x 是素数。
折枝寄北
2024/11/19
660
C语言初阶小练习1（1.素数的打印，2.闰年的判断和打印,3.求解两个数的最大公约数）
练习10—素数判断
java数据类型数学
题目 编写一个判断素数的函数，在主函数输入一个整数，输出该数是否为素数的信息。 解题步骤 （1）函数思想； （2）素数定义； （3）变量定义； （4）接收用户输入； （5）判断输出； Java import java.util.Scanner; public class Demo { public static boolean isPrime(int input) { int n = (int) Math.sqrt(input); if (input =
攻城狮杰森
2022/06/03
2890
C语言实例：求100——200之间的所有素数
编程算法
素数是大于1的整数，除了能被自身和1整除外，不能被其他正整数整除。算法过程是：让i被2～i除，如果i能被2～i之间的任何一个整数整除，则结束循环；若不能被整除，则要判断j是否是最接近或等于i的，如果是则证明是素数，否则继续下次循环。
C语言中文社区
2022/05/30
1.7K0
C语言实例：求100——200之间的所有素数
8个基础且实用的C语言经典实例【附源码】
编程算法
程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除，则表明此数不是素数，反之是素数。
C语言中文社区
2022/05/31
3550
8个基础且实用的C语言经典实例【附源码】
素数推断算法(高效率）
编程算法
关于素数的算法是信息学竞赛和程序设计竞赛中常考的数论知识，在这里我跟大家讲一下寻找一定范围内素数的几个算法。看了以后相信
全栈程序员站长
2022/07/14
3400
C语言一百例（11-20）
11，题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？ 程序分析：兔子的规律为数列1,1,2,3,5,8,13,21....
紫禁玄科
2022/03/24
4410
判断一个数是否为素数(质数) c语言[通俗易懂]
httpsjava网络安全
质数又称素数。一个大于1的自然数，除了1和它自身外，不能被其他自然数整除的数叫做质数。最小的质数是2，它也是唯一的偶数质数。 原理：number 只需被 (2 ~ 根号下number)之间的每一个整数去除就可以了（包括 根号下number这个数）。如果 nummber不能被 (2 ~ 根号下number) 间任一整数整除，number 必定是素数
全栈程序员站长
2022/07/23
1.7K0
判断一个数是否为素数(质数) c语言[通俗易懂]
素数相关问题练习 C++
c++
辗转相除 #include <iostream> using namespace std; int gcb(int a,int b) { if(b==0) return a; return gcb(b,a%b); } int main() { int a,b; cin>>a>>b; cout<<gcb(a,b); } 素数判定 #include <stdio.h> #include <math.h> #include <vector> using namespac
kalifa_lau
2018/04/26
6800
C语言经典习题100例（三）11-15
for循环
实现思路： 从第1个月起，兔子对数分别为1、1、2、3、5、8、13、21…，显然是斐波拉契数列。
cutercorley
2020/07/23
4300
C语言经典习题100例（三）11-15
C语言经典编程题100例 31~40
编程算法
31、题目：请输入星期几的第一个字母来判断一下是星期几，如果第一个字母一样，则继续判断第二个字母。
C you again
2022/08/22
1.4K0
打印100~200之间的素数
countint博客效率优化
可以使用 2 到 i-1 之间的数去试除  i，如果2 到 i-1 之间没有数能整除 i ，那么i就是素数
阿伟@t
2023/10/10
2260
打印100~200之间的素数
C/CPP基础PTA习题及分析
intpssizeof
已知素数序列为2、3、5、7、11、13、17、19、23、29……，即素数的第一个是2，第二个是3，第三个是5……那么，随便挑一个数，若是素数，能确定是第几个素数吗？如果不是素数，则输出0。
CtrlX
2023/03/21
7100
C语言经典例题100
c 语言c++云+校园腾讯云开发者社区腾讯云学堂
题目：有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？
C语言与CPP编程
2021/04/02
2.9K0
C语言经典例题100
从零开始学算法：高精度计算
编程算法存储
前言:由于计算机运算是有模运算,数据范围的表示有一定限制,如整型int(C++中int 与long相同)表达范围是(-2^31~2^31-1),unsigned long(无符号整数)是(0~2^32-1),都约为几十亿.如果采用实数型,则能保存最大的double只能提供15~16位的有效数字,即只能精确表达数百万亿的数.因此,在计算位数超过十几位的数时,不能采用现有类型,只能自己编程计算. 高精度计算通用方法:高精度计算时一般用一个数组来存储一个数,数组的一个元素对应于数的一位(当然,在以后的学习中为了加
Angel_Kitty
2018/04/08
1.3K0
C++经典算法题-最大公因数、最小公倍数、因式分解
algorithm
最大公因数使用辗转相除法来求，最小公倍数则由这个公式来求：GCD * LCM = 两数乘积
cwl_java
2022/11/30
6740
C语言-----分支和循环
return数组字符串caseint
if语句后面不加分号，默认情况下if和else语句后面只能跟一条语句,如果要使用多条语句，可以用{}将想要多条表达的式子放进去
凯子坚持C
2024/09/23
1220
推荐阅读
编辑精选文章
万字详解高可用架构设计Go 开发者必备：Protocol Buffers 入门指南10分钟带你彻底搞懂分布式链路跟踪
相关讨论
C语言实现动态菜单，智慧的C语言？C语言 指针的问题？c++比c语言好在哪里？
相关课程
AI驱动的TDSQL-Cserverless实战营C/Python数字化IT从业者知识体系
C语言如何判断素数及相关知识
2.6K0
经典例题（一）——经典例题的归纳总结。
5390
c语言必会题目
1040
C语言基础程序——入门经典100道实例
5070
C语言初阶小练习1（1.素数的打印，2.闰年的判断和打印,3.求解两个数的最大公约数）
660
练习10—素数判断
2890
C语言实例：求100——200之间的所有素数
1.7K0
8个基础且实用的C语言经典实例【附源码】
3550
素数推断算法(高效率）
3400
C语言一百例（11-20）
4410
判断一个数是否为素数(质数) c语言[通俗易懂]
1.7K0
素数相关问题练习 C++
6800
C语言经典习题100例（三）11-15
4300
C语言经典编程题100例 31~40
1.4K0
打印100~200之间的素数
2260
C/CPP基础PTA习题及分析
7100
C语言经典例题100
2.9K0
从零开始学算法：高精度计算
1.3K0
C++经典算法题-最大公因数、最小公倍数、因式分解
6740
C语言-----分支和循环
1220
相关推荐
C语言如何判断素数及相关知识
更多 >
CtrlX0
LV.1
这个人很懒，什么都没有留下～
文章
124
获赞
282
专栏
1
作者相关精选
换一批
加入讨论
的问答专区 >
码事漫谈0
1高级后端开发工程师擅长3个领域
相关课程
一站式学习中心 >
AI驱动的TDSQL-Cserverless实战营
1413人在学
云原生数据库 TDSQL-C
C/Python
748人在学
c 语言
python
数字化IT从业者知识体系
385人在学
CODING DevOps
软件开发
领券

腾讯云开发者

扫码关注腾讯云开发者

扫码关注腾讯云开发者

领取腾讯云代金券

热门产品

热门推荐

更多推荐

Copyright © 2013 - 2025 Tencent Cloud. All Rights Reserved. 腾讯云 版权所有 

深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 深公网安备号 44030502008569

腾讯云计算（北京）有限责任公司 京ICP证150476号 |  京ICP备11018762号 | 京公网安备号11010802020287

问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档

Copyright © 2013 - 2025 Tencent Cloud.

All Rights Reserved. 腾讯云 版权所有

登录 后参与评论
2
目录
本文部分代码块支持一键运行，欢迎体验
本文部分代码块支持一键运行，欢迎体验