PAT乙类1007之素数对猜想

一、题目

让我们定义d​n为：d​n=pn+1−pn，其中p​i是第i个素数。显然有d1=1，且对于n>1有d​n是偶数。“素数对猜想”认为“存在无穷多对相邻且差为2的素数”。
现给定任意正整数N(<10​^5)，请计算不超过N的满足猜想的素数对的个数。

  输入格式:
  输入在一行给出正整数N。

  输出格式:
  在一行中输出不超过N的满足猜想的素数对的个数。

  输入样例:
  20
  输出样例:
  4

二、代码

方法一 ：

• 常用函数

1. 本题目中需要自己掌握的就是素数的判断！！！在代码之后我详细介绍了素数的相关知识！！
2. sqrt函数， 它不需要像在java中还需要Math.sqrt来调用，直接使用就行了。

• 核心思想
  1）本题最为核心的是不在于如何判断素数，而在于素数判断成功后如何保存，保存后再进行比较！
  所以我选择了数组a[2]， 没错只有两个元素，节省了很多空间。 它的存储数值是动态的，只要有两个数之后，不管满足不满足a[1] - a[0] == 2的条件，都要使a[0] = a[1], 让a[1]来存储新的素数!!!而且下标k也是动态变化的！！！！

• bug调试过程

1. 开始时，我的问题是n与i不分， 因为是不超过n的数进行遍历，所以这个i才是遍历的对象， 我在后面isPrime的时候用的n
   2）原文中是不超过n， 意思是包含n， 是i>=n
   3）我原来将k下标的修改位置放在了if条件a[1] - a[0] == 2之下，发现是错误的； 因为满足的只是少数，这样a[2]一直得不到更新

#include <iostream>
#include <math.h>
using namespace std;

bool isPrime(int n) {
	if(n <= 3) {
		return n > 1;
	}
	int m = (int)sqrt(n);
	for(int i=2; i <= m; i++) {
		if(n % i == 0) {
			return false;
		}
	}
	return true;
}

int main() {
	int n;
	cin>>n;
	int a[2];
	int  k = 0, sum = 0;
	for(int i=1; i<=n; i++) {
		if(isPrime(i)) {
			a[k] = i;
			k++;
			if(k == 2) {
				if(a[1] - a[0] == 2) {
					sum++;
				}
				a[0] = a[1];
				k = 1;
			}
		}
	}
	cout<<sum;
	return 0;
}

方法二：

在网上搜寻后，看到了另一种解决方法，感觉很简洁，分享一下!!

• 核心思想

1. 代码将 N<=4 和 N >=3 做了分割，是我们需要警惕的！！可能因为n = 2， 3，5都是质数（素数），只要2和3两个特殊！！
2. 当n>3=时, 恢复正常判断。只需要一个 **isPrime(i) && isPrime(i + 2)**就可以判断出来， 让我很佩服！！！！

#include <stdio.h>
#include <math.h>
#include <stdbool.h>
bool isPrime(int);
 
int main(void)
{
	int N,i;
	int count = 0;
	scanf("%d", &N);
	if (N <= 4)
		printf("0");
	else
	{
		for (i = 3; i <= N - 2; i++)
			if (isPrime(i) && isPrime(i + 2))
				count++;
		printf("%d",count);
	}	
	return 0;
}
bool isPrime(int n)
{
	int i;
	if (n == 1 || n == 0)
		return false;
	else
	{
		for (i = 2; i <= sqrt((double)n); i++)
			if (n%i == 0)
				return false;
	}
	return true;

三、素数(转载的)

作者：阿飞__
来源：CSDN
原文：https://blog.csdn.net/afei__/article/details/80638460
版权声明：本文为博主原创文章，转载请附上博文链接！

一、概念介绍

大家中学都学过，就不过多介绍了，大致提两点：

• 质数又称素数。一个大于1的自然数，除了1和它自身外，不能被其他自然数整除的数叫做质数；否则称为合数。
• 0和1既不是质数也不是合数，最小的质数是2

Attention!!! 最小的质数是 2！！！！！ 所以当时1或者0的时候， 直接返回不是素数!!!

二、方法介绍

1.最直观，但效率最低的写法

public static boolean isPrime(int n){
    if (n <= 3) {
        return n > 1;
    }
    for(int i = 2; i < n; i++){
        if (n % i == 0) {
            return false;
        }
    }
    return true;
}

这里特殊处理了一下小于等于3的数，因为小于等于3的自然数只有2和3是质数。
然后，我们只需要从2开始，一直到小于其自身，依次判断能否被n整除即可，能够整除则不是质数，否则是质数。

2.初步优化

假如n是合数，必然存在非1的两个约数p1和p2，其中p1<=sqrt(n)，p2>=sqrt(n)。由此我们可以改进上述方法优化循环次数。如下：

public static boolean isPrime(int n) {
    if (n <= 3) {
        return n > 1;
    }
    int sqrt = (int)Math.sqrt(n);
    for (int i = 2; i <= sqrt; i++) {
        if(n % i == 0) {
            return false;
        }
    }
    return true;
}

3.继续优化

我们继续分析，其实质数还有一个特点，就是它总是等于 6x-1 或者 6x+1，其中 x 是大于等于1的自然数。
如何论证这个结论呢，其实不难。首先 6x 肯定不是质数，因为它能被 6 整除；其次 6x+2 肯定也不是质数，因为它还能被2整除；依次类推，6x+3 肯定能被 3 整除；6x+4 肯定能被 2 整除。那么，就只有 6x+1 和 6x+5 (即等同于6x-1) 可能是质数了。所以循环的步长可以设为 6，然后每次只判断 6 两侧的数即可。

public static boolean isPrime(int num) {
    if (num <= 3) {
        return num > 1;
    }
    // 不在6的倍数两侧的一定不是质数
    if (num % 6 != 1 && num % 6 != 5) {
        return false;
    }
    int sqrt = (int) Math.sqrt(num);
    for (int i = 5; i <= sqrt; i += 6) {
        if (num % i == 0 || num % (i + 2) == 0) {
            return false;
        }
    }
    return true;
}

对于输入的自然数 n 较小时，也许效果不怎么明显，但是当 n 越来越大后，该方法的执行效率就会越来越明显了。