C++ 笔试题简单练习----求N 以内质数 和 计算多少对质数等于N

1、关于质数的操作
* 素数（质数）：只能被1和自身整除的数*
若一个数N为合数，则存在a,b,使得N=a*b，且a,b中至少有一个数小于sqrt(N) ,因为N = 2^( sqrt(N) );判断时就可以减少循环次数；

直接法

/* 给定一个正整数，编写程序计算有多少对质数的和等于输入的这个正整数，并输出结果。输入值小于1000；
*  如，输入为10，程序应该输出结果为2。（共有两对质数的和为(5,5),(3,7) )
*/

/* 给定一个正整数，编写程序计算有多少对质数的和等于输入的这个正整数，并输出结果。输入值小于1000；
*  如，输入为10，程序应该输出结果为2。（共有两对质数的和为(5,5),(3,7) )
*/

#include <iostream> 
#include <cmath>
using namespace std;

void Prime_fun (int n);

int main (void) {

    cout<<"Please input a integer N(0<N<1000):"<<endl;
    int N;
    cin>>N;
    Prime_fun(N);

    return 0;
}

void Prime_fun (int n)  {
    if (n == 2) {
        cout<<n<<endl;

    }
    //int num;
    bool m; //因为只有两种状态，改为bool类型 

    //考虑把下面的功能以函数形式实现 
    int count = 0;
    int* res = new int ;
    int len = 0;

    //找出所有小于N的质数； 
    for (int i = 2; i < n; i++) {
        m = true;
        for (int j = 2; j < (int)sqrt(i*1.0); j++) { //只用判断到sqrt(i)即可，时间快了很多 （小细节sqrt(i*1.0)）
            if (i % j == 0) {
                m = false;
                break; //注意 这里当有一个可以整除就代表
                       //不是质数了，这时就可以结束循环，判断下一个i了 
            }
        }
        if (m) {
            res[count] = i; //将满足条件的质数保存起来 
            count++;
            cout<<i<<endl;
        }
    }

    //计算对数 
    int value = 0;
    for (int i = 0; i < count; i++) {
        for (int j = 0; j <= i; j++) {
            if ((res[i]+res[j]) == n  ) {
                cout<<res[i]<<","<<res[j]<<endl;
                value++;
            }
        }
    }

    cout<<value<<endl;

    cout<<endl;//换行 得记住了 

    delete [] res;//不能忘记，以免内存泄露； 
}

直接法优化算法 ：对循环进行的次数进行优化

/* 给定一个正整数，编写程序计算有多少对质数的和等于输入的这个正整数，并输出结果。输入值小于1000；
*  如，输入为10，程序应该输出结果为2。（共有两对质数的和为(5,5),(3,7) )
*/

#include <iostream> 
#include <cmath>
#include <ctime>
using namespace std;
#define MAX 1000

void Prime_fun (int n);

int main (void) {
    //clock_t start,finish;
    //start = clock();
    cout<<"Please input a integer N(0<N<1000):"<<endl;
    int N;
    cin>>N;
    Prime_fun(N);

    //finish = clock();
    //cout<<finish-start<<endl;
    return 0;
}

void Prime_fun (int n)  {
    //int num;
    bool m; //因为只有两种状态，改为bool类型 

    //考虑把下面的功能以函数形式实现 
    int count = 0;
    int* res = new int [MAX] ;
    int len = 0;

    //cout<<"2"<<endl;
    ++count;// "2" 直接算一个 
    res[0] = 2;
    //找出所有小于N的质数； 
    for (int i = 3; i < n; i++) {
        m = true;
        for (int j = 0; j < count; j++) { //只用判断到sqrt(i)即可，时间快了很多 
            if (i % res[j] == 0) { //比i小的质数都不能整除即可，不用2~sqrt(i)所有的数；
                                   //因为合数都能分解成质数 
                //cout<<"count；"<<count<<endl; 
                m = false;
                break; //注意 这里当有一个可以整除就代表
                       //不是质数了，这时就可以结束循环，判断下一个i了 
            }
        }
        if (m) {
            res[count] = i; //将满足条件的质数保存起来 
            count++;
            //cout<<i<<endl;
        }
    }

    //计算对数 
    int value = 0;
    for (int i = 0; i < count; i++) {
        for (int j = 0; j <= i; j++) {
            if ((res[i]+res[j]) == n  ) {
                //cout<<res[i]<<","<<res[j]<<endl;
                value++;
            }
        }
    }

    cout<<value<<endl;

    //cout<<endl;//换行 得记住了 

    delete [] res;//不能忘记，以免内存泄露； 
}

间接法

/*如果只关心有几个质数的话，可以采用逆向思维：合数过滤筛选法*/
#include <iostream> 
using namespace std;
#define MAX 10000

int main (void) {
    cout<<"Please input a integer :"<<endl;
    int N;
    cin>>N;

    //建立一个数组，将2-N全置为1，表示是质数， 
    int *res = new int[MAX];
//  res[0] = 0;
//  res[1] = 0;
    for (int i=2; i <= N; i++) {
        res[i] = 1;
        //cout<<res[i]<<" ";
    }

    //合数肯定能分解成两个质数的和；将合数置为0； 
    for (int i=2; i <= N - 1; i++) {  //以2 ~ N-1  为过滤区间 
        for (int j=2; i*j <= N; j++) {
            res[i*j] = 0; //i*j 由两整数相乘而得，显然不是素数； 
        }
    }

    //统计N以内的质数个数并输出 
    cout<<endl;
    int count = 0;
    for (int i=2; i <= N; i++) {
        if ( res[i] == 1 ) {
            count++;    
        }
        //cout<<res[i]<<" ";
    }

    //cout<<endl;
    cout<<count<<endl;

    delete [] res;//总是忘记，下次记得提前写好； 
    return 0;
}

间接法优化算法

/*如果只关心有几个质数的话，可以采用逆向思维：合数过滤筛选法*/
#include <iostream> 
using namespace std;
#define MAX 10000

int main (void) {
    cout<<"Please input a integer :"<<endl;
    int N;
    cin>>N;

    //建立一个数组，将2-N全置为1，表示是质数， 
    int *res = new int[MAX];
//  res[0] = 0;
//  res[1] = 0;

//优化1：初始化时候我们把奇数置1，偶数置0，因为我们知道质数是奇数
//这样就省去了后面对偶数的判断，只用判断奇数即可
    res [2] = 1;
    for (int i=3; i < N; i+=2) {
        res[i] = 1;
        res[i+1] = 0;
        //cout<<res[i]<<" ";
    }
    if (N%2 != 0) {
        res[N] = 1;
    } 

    //考虑到i*j和j*i的重复，故i只取到N/2 只计算奇数 
    for (int i=3; i <= N/2; i+=2) {  //以2 ~ N-1  为过滤区间 
        for (int j=3; i*j <= N; j+=2) {
            res[i*j] = 0; //i*j 由两整数相乘而得，显然不是素数； 
        }
    }

    //统计N以内的质数个数并输出 
    cout<<endl;
    int count = 0;
    for (int i=2; i <= N; i++) {
        if ( res[i] == 1 ) {
            count++;    
        }
        //cout<<res[i]<<" ";
    }

    //cout<<endl;
    cout<<count<<endl;

    delete [] res;//总是忘记，下次记得提前写好； 
    return 0;
}