洛谷 B3939 [GESP 样题四级] 绝对素数：从概念到代码全解析

大家在学习编程的过程中，肯定遇到过各种有趣的数学问题，今天我们要聊的就是 “幻方”。先问大家一个问题：你见过把数字排成正方形，每行、每列、两条对角线加起来都相等的情况吗？这就是幻方！比如我们最熟悉的 3 阶幻方：plaintext8 1 63 5 72 9 4每行相加：8+1+6=15，3+5+7=15，2+9+4=15每列相加：8+3+2=15，1+5+9=15，6+7+4=15对角线相加：8+

2501_91189146

3710人浏览 · 2025-07-23 16:08:08

2501_91189146 · 2025-07-23 16:08:08 发布

洛谷 B3939 [GESP 样题四级] 绝对素数：从概念到代码全解析

恩师：hnjzsyjyj

一、什么是 “绝对素数”？—— 用例子说清楚

先问大家一个问题：你知道什么是素数吗？素数就是 “除了 1 和它自己之外，不能被其他数整除的自然数”。比如 2、3、5、7 都是素数，而 4（能被 2 整除）、6（能被 2 和 3 整除）就不是素数。

那 “绝对素数” 是什么呢？别急，我们先看两个例子：

13 是素数，把它的十位和个位交换一下，变成 31，31 也是素数 → 所以 13 是绝对素数
17 是素数，交换后变成 71，71 也是素数 → 17 是绝对素数
19 是素数，交换后变成 91，但 91=7×13（不是素数）→ 所以 19 不是绝对素数

看明白了吗？绝对素数（针对两位数）就是：一个两位数本身是素数，并且交换它的十位和个位数字后得到的新数也是素数。这就是今天要解决的问题核心！

二、题目分析：洛谷 B3939 到底要我们做什么？

虽然我们没有原题的描述，但通过代码可以反推题目要求。这道题（GESP 四级样题）的任务很明确：

输入两个整数 a 和 b（注意：题目里应该是两位数范围，比如 10≤a≤b≤99）
找出在 [a, b] 这个区间里的所有 “绝对素数”
把这些绝对素数一个个打印出来，每个数占一行

举个例子：如果输入是 “10 30”，那么输出应该是：

plaintext

为什么是这些数？我们来验证两个：

11：本身是素数，交换后还是 11（也是素数）→ 符合
13：本身是素数，交换后 31（也是素数）→ 符合
21：21=3×7（不是素数）→ 排除
23：本身是素数，交换后 32（32 是偶数，不是素数？不，32 是 2×16，确实不是素数？ Wait，不对，23 交换后是 32，32 不是素数，但上面例子里 23 却在输出里？哦，等一下，32 不是素数，那 23 为什么是？哦不，我算错了！23 交换后是 32 吗？不，23 的十位是 2，个位是 3，交换后是 32？32 确实不是素数啊！哦不对，我这里犯了个低级错误，23 交换后是 32 吗？32 能被 2 整除，所以不是素数。那为什么刚才的例子里有 23？哦，原来我举错例子了，正确的应该是 23 交换后是 32（非素数），所以 23 不是绝对素数。看来举例子也要严谨，后面我们会用代码验证正确的结果。

总之，题目就是让我们找出区间内 “自身是素数，交换后也是素数” 的两位数。

三、解决问题的思路：把大问题拆成小步骤

要解决这个问题，我们可以把它拆成三个小任务：

怎么判断一个数是不是素数？（需要一个 “素数判断函数”）
怎么交换一个两位数的十位和个位？（需要一个 “数字交换函数”）
怎么在 [a, b] 区间里逐个检查，找出符合条件的数？（主循环逻辑）

这三个步骤就像搭积木，组合起来就能解决问题。接下来我们就看看代码是怎么实现这三个步骤的。

四、代码逐行解读：从变量到函数，一句一句说清楚

先把完整代码贴出来，然后我们一句一句分析：

cpp

#include <bits/stdc++.h>
using namespace std;
int a,b,t;
int ans(int a){
    int x,y;
    x=a,y=a/10+a%10*10;
    return y;
}
bool ans2(int a){
    if(a<2)return false;
    for(int i=2;i*i<=a;i++){
        if(a%i==0)return false;
    }
    return true;
}
int main() {
    cin>>a>>b;
    for(int i=a;i<=b;i++){
        t=ans(i);
        if(ans2(i)&&ans2(t))cout<<i<<endl;
    }
    return 0;
}

这段代码虽然短，但五脏俱全，完美实现了我们刚才说的三个步骤。接下来我们逐个部分解析。

第一部分：头文件和全局变量

cpp

#include <bits/stdc++.h>
using namespace std;
int a,b,t;

#include <bits/stdc++.h>：这是 C++ 的 “万能头文件”，包含了所有常用的库（比如输入输出、数学运算等），写代码时不用再一个个引库，很方便。
using namespace std;：这句话的作用是 “告诉编译器，我们要用 std 这个命名空间里的东西”，比如后面的cin、cout都是 std 里的，如果没有这句话，就得写成std::cin、std::cout，比较麻烦。
int a,b,t;：定义了三个全局变量
- a和b：存储输入的区间范围（左边界和右边界）
- t：临时存储 “交换十位和个位后的数字”

第二部分：数字交换函数`ans(int a)`—— 怎么交换十位和个位？

cpp

int ans(int a){
    int x,y;
    x=a,y=a/10+a%10*10;
    return y;
}

这个函数的作用是：输入一个两位数a，返回交换十位和个位后的新数。比如输入 13，返回 31；输入 29，返回 92。

我们来拆解开：

int x,y;：定义两个临时变量，x 其实没用到（可能是代码遗留，不影响功能）
a/10：取十位数字。因为整数除法会舍去小数，比如 13/10=1，29/10=2
a%10：取个位数字。%是取余运算，13%10=3，29%10=9
a%10*10：把个位数字变成十位。比如 310=30，910=90
然后a/10 + a%10*10：十位数字（原个位）加上个位数字（原十位），就是交换后的数。比如 13 交换：13%10=3 → 3*10=30，13/10=1 → 30+1=31

小技巧：这个交换方法只适用于两位数！如果是三位数，比如 123，交换十位和个位是 132，算法就不一样了（需要先取百位、十位、个位），但这道题里是两位数，所以没问题。

第三部分：素数判断函数`ans2(int a)`—— 怎么判断素数？

cpp

bool ans2(int a){
    if(a<2)return false;
    for(int i=2;i*i<=a;i++){
        if(a%i==0)return false;
    }
    return true;
}

这个函数的作用是：输入一个整数a，返回true（是素数）或false（不是素数）。

我们逐句分析：

if(a<2)return false;：素数的定义是 “大于 1 的自然数”，所以小于 2 的数（0、1、负数）都不是素数，直接返回false。
for(int i=2;i*i<=a;i++)：从 2 开始循环，直到i*i大于a为止。为什么到i*i就够了？因为如果a有一个大于√a的因数，那么它一定有一个小于√a的配对因数。比如 100，√100=10，如果 100 能被 20 整除，那它一定能被 5 整除（5<10）。所以检查到i*i <=a就足够了，能减少循环次数，提高效率。
if(a%i==0)return false;：如果a能被i整除（余数为 0），说明a不是素数，返回false。
return true;：如果循环结束后都没找到能整除a的数，说明a是素数，返回true。

举例验证：

判断 13 是不是素数：
- 13≥2，进入循环
- i=2：13%2=1≠0 → 继续
- i=3：3*3=9≤13 → 13%3=1≠0 → 继续
- i=4：4*4=16>13 → 循环结束，返回true（13 是素数）
判断 15 是不是素数：
- i=2：15%2=1≠0 → 继续
- i=3：3*3=9≤15 → 15%3=0 → 返回false（15 不是素数）

第四部分：主函数`main()`—— 把所有步骤串起来

cpp

int main() {
    cin>>a>>b;
    for(int i=a;i<=b;i++){
        t=ans(i);
        if(ans2(i)&&ans2(t))cout<<i<<endl;
    }
    return 0;
}

主函数是程序的入口，负责 “输入→处理→输出” 的完整流程。

我们分步看：

cin>>a>>b;：从键盘输入两个整数a和b，表示区间的左右边界（比如输入 10 99）。
for(int i=a;i<=b;i++)：循环遍历区间内的每个数i（从a到b，包括a和b）。
t=ans(i);：调用ans函数，得到i交换十位和个位后的数t。
if(ans2(i)&&ans2(t))cout<<i<<endl;：
- ans2(i)：判断i是不是素数
- ans2(t)：判断交换后的t是不是素数
- 只有当两个都是true（即i和t都是素数）时，才输出i
return 0;：程序正常结束。

五、代码运行全过程演示：用例子走一遍

为了让大家更清楚，我们用一个具体的例子演示代码的执行过程。假设输入是10 20，看看程序会输出哪些数。

输入：10 20 → 遍历 i=10 到 20

i=10：
- t=ans(10)：10/10=1，10%10=0 → 0*10+1=1 → t=1
- 检查 ans2 (10)：10 能被 2 整除 → false → 不输出
i=11：
- t=ans(11)：11/10=1，11%10=1 → 1*10+1=11 → t=11
- 检查 ans2 (11)：11 是素数（true）；ans2 (11) 也是 true → 输出 11
i=12：
- t=ans(12)=21
- ans2 (12)：12 能被 2 整除 → false → 不输出
i=13：
- t=ans(13)=31
- ans2 (13)：13 是素数（true）；ans2 (31)：31 是素数（true）→ 输出 13
i=14：
- t=ans(14)=41
- ans2 (14)：14 能被 2 整除 → false → 不输出
i=15：
- t=ans(15)=51
- ans2 (15)：15 能被 3 整除 → false → 不输出
i=16：
- t=ans(16)=61
- ans2 (16)：16 能被 2 整除 → false → 不输出
i=17：
- t=ans(17)=71
- ans2 (17)：17 是素数（true）；ans2 (71)：71 是素数（true）→ 输出 17
i=18：
- t=ans(18)=81
- ans2 (18)：18 能被 2 整除 → false → 不输出
i=19：
- t=ans(19)=91
- ans2 (19)：19 是素数（true）；ans2 (91)：91=7×13 → 不是素数 → false → 不输出（这里纠正之前的错误！19 交换后是 91，91 不是素数，所以 19 不是绝对素数）
i=20：
- t=ans(20)=02=2
- ans2 (20)：20 能被 2 整除 → false → 不输出

输出结果：11、13、17

这就是代码处理 10-20 的过程，结果正确吗？我们再验证：

11：11 是素数，交换后 11 也是素数 → 正确
13：13 是素数，交换后 31 是素数（31 只能被 1 和 31 整除）→ 正确
17：17 是素数，交换后 71 是素数 → 正确
19：交换后 91=7×13 → 不是素数，所以不输出 → 正确

六、常见问题解答：这些坑你可能会踩

1. 为什么函数名是`ans`和`ans2`？看起来不太直观？

这是代码作者起的名字，可能比较随意。在实际编程中，建议起有意义的名字，比如swapDigits（交换数字）和isPrime（是否素数），这样代码可读性更好。比如：

cpp

// 交换十位和个位
int swapDigits(int num) {
    int tens = num / 10;
    int units = num % 10;
    return units * 10 + tens;
}

// 判断素数
bool isPrime(int num) {
    if (num < 2) return false;
    for (int i = 2; i * i <= num; i++) {
        if (num % i == 0) return false;
    }
    return true;
}

这样的名字一看就知道函数的作用，推荐大家在写代码时养成好习惯。

2. 代码里的`x`变量没用到，为什么还定义？

在ans函数里，x=a这句代码之后，x就再也没被使用过，属于多余代码。这种情况在编程中很常见（比如调试时临时加的变量忘记删除），虽然不影响程序运行，但会降低可读性，实际写代码时要尽量避免。

3. 素数判断函数为什么循环到`i*i <=a`，而不是`i <=a-1`？

这是一个优化！如果循环到i <=a-1，比如判断 10000 是否为素数，需要循环 9998 次；而循环到i*i <=a，只需要循环到 100（100*100=10000），大大减少了循环次数。对于这道题里的两位数（最大 99），两种方法差别不大，但对于大数，效率差距就很明显了。

4. 输入的`a`和`b`如果不是两位数怎么办？

题目中应该隐含了a和b是两位数（10≤a≤b≤99），因为：

一位数交换十位和个位会变成两位数（比如 5 交换后是 50，50 不是素数）
三位数及以上的交换逻辑和代码中的ans函数不符（比如 100 交换后是 001=1，不是素数）

如果输入的a小于 10，代码也能处理，但输出可能为空（比如 5 是素数，交换后是 50，50 不是素数，所以 5 不是绝对素数）。

5. 所有的两位绝对素数有哪些？

我们可以用代码跑一遍 10-99，找出所有绝对素数：
11、13、17、31、37、71、73、79、97

验证几个：

31：31 是素数，交换后 13 是素数 → 是
37：37 是素数，交换后 73 是素数 → 是
79：79 是素数，交换后 97 是素数 → 是
97：97 是素数，交换后 79 是素数 → 是

这些就是所有的两位绝对素数，共 9 个。

七、代码优化：让代码更高效、更易读

虽然这段代码能正确解决问题，但我们可以从 “可读性” 和 “效率” 两方面优化：

优化 1：重命名函数和变量

把ans改为swapDigits，ans2改为isPrime，t改为swappedNum，让代码一目了然：

cpp

#include <bits/stdc++.h>
using namespace std;

// 交换两位数的十位和个位
int swapDigits(int num) {
    int tens = num / 10;
    int units = num % 10;
    return units * 10 + tens;
}

// 判断是否为素数
bool isPrime(int num) {
    if (num < 2) return false;
    for (int i = 2; i * i <= num; i++) {
        if (num % i == 0) return false;
    }
    return true;
}

int main() {
    int a, b;
    cin >> a >> b;
    for (int i = a; i <= b; i++) {
        int swappedNum = swapDigits(i);
        if (isPrime(i) && isPrime(swappedNum)) {
            cout << i << endl;
        }
    }
    return 0;
}

优化 2：素数判断的小技巧

在素数判断中，可以先排除偶数（除了 2 之外的偶数都不是素数），减少循环次数：

cpp

bool isPrime(int num) {
    if (num < 2) return false;
    if (num == 2) return true; // 2是唯一的偶素数
    if (num % 2 == 0) return false; // 其他偶数都不是素数
    for (int i = 3; i * i <= num; i += 2) { // 只检查奇数
        if (num % i == 0) return false;
    }
    return true;
}

对于两位数来说，这个优化效果不明显，但对于大数来说，能减少一半的循环次数。