自己写的，段错误（数组越界，堆栈溢出，递归太多）

而且审错题，应该是第1到第10000个素数==而不是1到10000间的素数

#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;

int main()
{
    int p[5005];
    int m,n,num=0;
cin>>m>>n;
for(int i=0;i<=10000;i++)
{
    int j;
    for( j=2;j<=i/2;j++)
    {
        if(i%j==0)
            break;
    }

    if( j==i/2+1)
        p[num++]=i;
}

int countt=0;
for(int q=m-1;q<n;q++)//排版
{
    countt++;
    if(!(countt%10))
    {
        cout<<p[q]<<endl;
    }
    else{
        if(q==n-1)
            cout<<p[q];
        else cout<<p[q]<<" ";}
    }

    return 0;
}

2. ，也是错的，同样审错题，但为什么↓

不能高亮关键代码真的很烦烦

#include <iostream>
using namespace std;
int a[10000];
bool isPrime(int num)//判断是否为素数
{
	if(num == 2) 
		return true;
	for(int i=2;i*i<=num;i++)
	{
		if(num%i == 0)
			return false;
	}
	return true;
}
int main()
{
	int i=0,count=0;
	int start,end;
	for(int j=2;j<=10000;j++)
	{
		if(isPrime(j))
			a[i++] = j;
	}
	cin >> start >> end;
	for(int i=start-1;i<end;i++)
	{
		count++;
		if(count%10 == 0)//排版
		{
			cout << a[i];
			cout << endl;
		}	
		else
		{
			if(i==end-1)
				cout << a[i];
			else
				cout << a[i] << " ";
		}
	}	
	return 0;
}

3.普通筛选法--埃拉托斯特尼筛法

先简单说一下原理：

基本思想：素数的倍数一定不是素数
实现方法：用一个长度为N+1的数组保存信息（0表示素数，1表示非素数），先假设所有的数都是素数（初始化为0），从第一个素数2开始，把2的倍数都标记为非素数（置为1），一直到大于N；然后进行下一趟，找到2后面的下一个素数3，进行同样的处理，直到最后，数组中依然为0的数即为素数。
说明：整数1特殊处理即可。

 #include <iostream>  
#include <cstring>
using namespace std;
#define N 10005
#define M 200005
bool check[M];
long prime[N];

int main()
{
int tot = 0, m, n, count = 0;
memset(check, 0, sizeof(check));
for (int i = 2; tot <= N; i++) {
if (!check[i])
prime[tot++] = i;
for (int j = 2 * i; j <= M; j += i) {//素数的倍数依然为倍数
check[j] = true;
}
}
cin >> m >> n;
for (int i = m; i <= n; i++) {
cout << prime[i-1];//另一种写法
if (++count % 10 == 0 && i != n)
cout << endl;
else if (i != n)
cout << " ";
}
return 0;
}

C/C++: short , int , long , long long数据类型选用

标签： C/C++ 数据类型

by 小威威

在C++中，编译器对int类型数据的执行效率最高。一般在符合int条件的情况下优先选择int。
那么，选择数据类型的条件是什么呢？
我认为，大于30000的数字应当使用long类型，超过20亿的数字应当使用long long类型。原因如下：

在32位的系统中：
`short`与`int`占两个字节， `long` 占四个字节， `long long` 占八个字节；
在64位的系统中：
`short`占两个字节， `int` 与 `long` 占四个字节， `long long` 占八个字节。

(注：2的16次方＝ 65536 ； 2的32次方＝ 4294672296； 2的64位＝ 18446744073709551616)

为什么大于30000的数字应当用long类型呢？在64位系统中int类型占四个字节，是32位，不是足以储存大于30000的部分数字的么？

int a = 40000; 
long b = 40000;

这主要是考虑到代码的移植性问题。因为在64位系统中，int类型占4个字节，但在32位系统中，int类型占2个字节。也就是说，当我们把一个大于(65536／2)的数用int类型储存，在64位系统上不会出现问题，但是将此程序在32位系统运行时数据就会超出范围，导致结果错误。因此，为了确保代码移植性高，应将大于(65536／2)的数定义为long类型。

同理，当数字大于(4294672296／2)时，应定义数据为long long 类型。

那么，什么时候用short类型呢？不是说一般优先考虑int类型么？原因如下：

在32位系统中，定义一个short类型的数组与一个int类型数组，其存储的数据在short的范围以内。此时将代码放在64位系统运行，int类型数组所占用的内存大约是short类型数组的两倍。大大增加了内存的占用。因此，在这种情况下，还是用short 类型数组较为妥当。

总而言之，大于30000的数据用long类型储存，大于20亿的数据用 long long储存。

1003数素数（20）

C/C++: short , int , long , long long数据类型选用

猜你喜欢