这一道题是函数问题，我们来看看吧

1. 首先解锁新的方式：函数
2. 函数一共有几常见的类型（不止这些）int char string void bool 等等，定义的值就是返回值的形式（void没有返回值）
3. 可以定义一个bool 类型的函数来判断素数，可以把函数名命名为 sushu
4. 首先可以确认的是：是个四位数，范围是从 1000~2999
5. 用一个循环遍历所有数，并且看看每一个是否是素数，如果所有都是，就是纯粹素数，输出即可
6. 注意：记得换行哦~（函数中代码一样写）

上代码吧~（AC过）

#include <bits/stdc++.h>
using namespace std;
bool sushu(int n)
{
    for (int i = 2; i < n; i++) if (n % i == 0) return false;
    return true;
}
int main()
{
    for (int i = 1000; i < 3000; i++) 
    {
        if (sushu(i) && sushu(i % 1000) && sushu(i % 100) && sushu(i % 10) && i % 10 != 1) 
            cout << i << endl;
    }
    return 0;
}

奇怪但合理的做法

#include<bits/stdc++.h>
using namespace std;
int main()
{
    cout << 1013 << endl;
    cout << 1097 << endl;
    cout << 1103 << endl;
    cout << 1223 << endl;
    cout << 1283 << endl;
    cout << 1307 << endl;
    cout << 1367 << endl;
    cout << 1373 << endl;
    cout << 1523 << endl;
    cout << 1607 << endl;
    cout << 1613 << endl;
    cout << 1823 << endl;
    cout << 1907 << endl;
    cout << 1997 << endl;
    cout << 2003 << endl;
    cout << 2017 << endl;
    cout << 2053 << endl;
    cout << 2083 << endl;
    cout << 2113 << endl;
    cout << 2137 << endl;
    cout << 2347 << endl;
    cout << 2383 << endl;
    cout << 2467 << endl;
    cout << 2503 << endl;
    cout << 2617 << endl;
    cout << 2647 << endl;
    cout << 2683 << endl;
    cout << 2797 << endl;
    cout << 2953 << endl;
    return 0;
}

另外我还有一个重要发现： 这些纯粹素数似乎都是以3和7结尾的

1.肯定是要用函数的，因为要判断质数；又因为要判断题中要求的数是否为素数，所以与其用void，还是不如用bool，这样if可以直接调用返回值 2.写好(万能)头文件后和万能标识符后，定义prime函数，让x对2~x-1范围内的数进行取余，此处要用到for循环，只要有一个是n的因数，返回false。因为返回语句会结束整个函数，所以不用break。如果for中没有返回，则返回true。以后就可以套用框架了(此函数不是方程😄 ）

bool prime(int x)
{
    for(int i=2;i<x;i++)
    {
        if(x%i==0)
        {
            return false;
        }
    }
    return true;
}

3.写好之后，开始写主函数。使用for循环让1000~2999的每一个数进行纯粹素数判断。用写好的prime函数来判断题中的几个数（取余）后是否为质数后，用if来判断他们的返回值，中间用&&运算符。注意！！！还要判断个位是否是1，因为1既不是质数，也不是合数！！！ 刚测试完，我就得到了一个大大的“哇！”（即WA，Wrong Answer）多谢@hetao794786的题解，我才注意到 （忠言也不逆耳嘛）

for(int i=1000;i<3000;i++)
    if(prime(i)&&prime(i%10)&&prime(i%100)&&prime(i%1000)&&!(i%10==1))

4.if语句成立后，输出i并换行 5.保持好习惯，return 0; 此解法最简单

废话说了一箩筐，上代码 （点个赞）

#include <iostream>
using namespace std;
bool prime(int x)
{
    for(int i=2;i<x;i++)
    {
        if(x%i==0)
        {
            return false;
        }
    }
    return true;
}
int main()
{
    for(int i=1000;i<3000;i++)
    {
        if(prime(i)&&prime(i%10)&&prime(i%100)&&prime(i%1000)&&!(i%10==1))
        {
            cout<<i<<endl;
        }
    }
    return 0;
}

P.S. 万能头和万能标识符即这俩家伙，也是必不可少的

#include <bits/stdc++.h>//通常用iostream
using namespace std;

P.S.的P.S. 这是讲给学渣（包括我，至少在C++方面）听得，学霸请退散 哦，我这句话是不是应该一开始就讲

printf("1013\n1097\n\n1103\n1223\n1283\n1307\n1367\n1373\n1523\n1607\n1613\n1823\n1907\n1997\n2003\n2017\n2053\n2083\n2113\n2137\n2347\n2383\n2467\n2503\n2617\n2647\n2683\n2797\n2953"); 没错但是有病的做法👍

#include <iostream>
using namespace std;
int prime(int n)
{
    bool fact = true;
    for (int i = 2; i <= n - 1; i++)
    {
        if (n % i == 0)
        {
            fact = false;
        }
    }
    return fact;
}
int main()
{
    for (int i = 1000; i < 3000; i++)
    {
        if (prime(i) && prime(i % 1000) && prime(i % 100) && prime(i % 10) && i % 10 != 1)
        {
            cout << i << endl;
        }
    }
    return 0;
}

这道题感觉挺难的非常“简单”，

代码也是浪费我不少时间轻轻松松打完！！！😕 😕 😕

话不多说，直接上代码！！！🚀️ 🚀️ 🚀️ （点个赞吧）

#include <bits/stdc++.h>
using namespace std;
bool LHX(int n) // 定义判断数n是否是素数的函数.
{
    for (int j = 2; j < n; j++)
    {
        if (n % j == 0)
        {
            return false; // 不是返回"false".
        }
    }
    return true; // 是返回"true".
}
int main()
{
    for (int i = 1000; i < 3000; i++) // i为判断的数.
    {
        int a = i % 1000; // a为判断的数的千位.
        int b = i % 100; // b为判断的数的百位.
        int c = i % 10; // c为判断的数的十位.
        if ((LHX(a) == true) && (LHX(b) == true) && (LHX(c) == true) && (LHX(i) == true) && (c != 1)) // 判断......
        {
            cout << i << endl; // 是的话输出i并换行.
        }
    }
}

#include <bits/stdc++.h>
using namespace std;
bool sushu(int n)
{
    for (int i = 2; i < n; i++) if (n % i == 0) return false;
    return true;
}
int main()
{
    for (int i = 1000; i < 3000; i++) 
    {
        if (sushu(i) && sushu(i % 1000) && sushu(i % 100) && sushu(i % 10) && i % 10 != 1) 
            cout << i << endl;
    }
    return 0;
}

蒟蒻扫盲计划NO.5

（核心）代码：

isprime（质数判断）部分:

if(k<2){
		return 0;//如果k<2（也就是为1或0）则直接干掉 
	}else{
		int i;
		for(i=2;i<sqrt(k)+1;i++){//sqrt(k)+1降低时间复杂度 
			if(k%i==0){
				return 0;//如果k%i==0,也直接干掉 
			}
		}
		return 1;//通过检测,k是真正的素数 ,返回1（true） 
	}

main部分:

for(i=1000;i<=3000;i++){
		int k=i,n,pw=1000;
		if(isprime(k)){//首先判断原来的k(也就是i)是不是素数，如果不是则跳过 
			if(isprime(k%1000)){
				if(isprime(k%100)){
					if(isprime(k%10)){
						cout<<k<<endl;//层层筛选 
					}
				}
			}
		}else{
			continue;
		}
	}

一手交赞，一手交码AWA

总结:

难点: 时间复杂度(过大可能会导致WA)

考点: 质数判断，函数运用

综合指数: ●●◖

c++14(o2)AC过，放心食用

#include <bits/stdc++.h>
using namespace std;
bool f(int n)
{
    if(n==1)
    {
        return 0;
    }
    for(int i=2;i<n;i++)
    {
        if(n%i==0)
        {
            return 0;
        }
    }
    return 1;
}
int main()
{
    int g,s,b;
    for(int i=1000;i<3000;i++)
    {
        g=i%10;
        s=i%100;
        b=i%1000;
        if(f(i) && f(g) && f(s) && f(b))
        {
            cout<<i<<endl;
        }
    }
    return 0;
}

自定义函数也是拿下好吧

#include<bits/stdc++.h>
using namespace std;
int sushu(int n){
	int f=1;
	if(n<=1)f=0;
	for(int i=2;i<=sqrt(n);i++){
		if(n%i==0){
			f=0;break;
		}
	}
	return f;
}
int main(){
	int f;
	for(int i=1000;i<3000;i++){
		int a=i%10;
		int b=i%100;
		int c=i%1000;
		if(sushu(i)==1&&sushu(c)==1&&sushu(b)==1&&sushu(a)==1){
			cout<<i<<endl;
		}
	}
	return 0;
}

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+5;//可加可不加
bool sushu(int x)
{
    for(int i=2;i<=sqrt(x);i++)//范围2~√x
    {
        if(x%i==0)
        {
            return 0;//不是素数
        }
    }
    return 1;//是素数
}
int main()
{
    for(int i=1000;i<3000;i++)//范围是1000~2999
    {
        if(sushu(i)&&sushu(i%1000)&&sushu(i%100)&&sushu(i%10)&&i%10!=1) //满足条件
            cout<<i<<endl;//输出
    }
}

经典无注释版

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+5;
bool sushu(int x)
{
    for(int i=2;i<=sqrt(x);i++)
    {
        if(x%i==0)
        {
            return 0;
        }
    }
    return 1;
}
int main()
{
    for(int i=1000;i<3000;i++)
    {
        if(sushu(i)&&sushu(i%1000)&&sushu(i%100)&&sushu(i%10)&&i%10!=1) 
            cout<<i<<endl;
    }
}

点完赞再走吧！！！

#include <bits/stdc++.h>
using namespace std;
bool sushu(int n)
{
    for (int i = 2; i < n; i++) if (n % i == 0) return false;
    return true;
}
int main()
{
    for (int i = 1000; i < 3000; i++) 
    {
        if (sushu(i) && sushu(i % 1000) && sushu(i % 100) && sushu(i % 10) && i % 10 != 1) 
            cout << i << endl;
    }
    return 0;
}

小于3000的四位纯粹数，遍历范围为1000~2999，遍历一次，判断

该数、该数对1000取余（去掉最高位剩百位数）、该数对100取余（再去掉最高位剩十位数）、该数对10取余（再去掉最高位剩个位数）是否为素数，

这里要注意再判断一下个位数是否为1，因为1不是素数。

素数判断：

bool prime(int n)  //素数判断
{
    for (int i = 2; i < n; i++)  //从2遍历到n-1
    {
        if (n % i == 0) //如果n取余当前数为0，则表示不是素数，直接返回false
        {
            return false;
        }
    }
    return true;
}

小于3000的四位纯粹数：

for (int i = 1000; i < 3000; i++) 
    {
        //判断当前数以及去掉最高位剩下的数是不是素数，最后注意判断只剩1位数时是否为1,1不是素数
        if (prime(i) && prime(i % 1000) && prime(i % 100) && prime(i % 10)&&(i%10!=1)) 
        {
            cout << i << endl;
        }
    }

c++(04)AC过，放心食用

#include <bits/stdc++.h>
using namespace std;
bool f(int n)
{
    if(n==1)
    {
        return 0;
    }
    for(int i=2;i<n;i++)
    {
        if(n%i==0)
        {
            return 0;
        }
    }
    return 1;
}
int main()
{
    int g,s,b;
    for(int i=1000;i<3000;i++)
    {
        g=i%10;
        s=i%100;
        b=i%1000;
        if(f(i) && f(g) && f(s) && f(b))
        {
            cout<<i<<endl;
        }
    }
    return 0;
}